hexsha
stringlengths 40
40
| size
int64 2
1.01M
| content
stringlengths 2
1.01M
| avg_line_length
float64 1.5
100
| max_line_length
int64 2
1k
| alphanum_fraction
float64 0.25
1
|
|---|---|---|---|---|---|
acfd9dab51a7c02cffd95f3b2cbee44739c12495 | 747 | cask "bandage" do
version "0.8.1"
sha256 "13e90e5824b61bd4abe62afa8785a28627714bf7a3d4dad3edb4b8f9854d3b6d"
url "https://github.com/rrwick/Bandage/releases/download/v#{version}/Bandage_Mac_v#{version.dots_to_underscores}.zip",
verified: "github.com/rrwick/Bandage/"
name "Bandage"
desc "Bioinformatics Application for Navigating De novo Assembly Graphs"
homepage "https://rrwick.github.io/Bandage/"
app "Bandage.app"
# shim script (https://github.com/Homebrew/homebrew-cask/issues/18809)
shimscript = "#{staged_path}/bandage.wrapper.sh"
binary shimscript, target: "bandage"
preflight do
IO.write shimscript, <<~EOS
#!/bin/sh
exec '#{appdir}/Bandage.app/Contents/MacOS/Bandage' "$@"
EOS
end
end
| 32.478261 | 120 | 0.729585 |
5d4a8ffe0a78b86d7818ded73301369372f0489f | 8,972 | #! /usr/bin/env ruby
# Copyright 2014 Frank Breedijk, Zate Berg, Trelor, Alex Smirnoff
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
require 'optparse'
require 'uri'
require 'net/https'
require 'rexml/document'
include REXML
options = {}
optparse = OptionParser.new do |opts|
opts.banner = "Nessus Wrapper for Seccubus v2\nUsage: ./nivil.rb [options] "
opts.on('-u', '--user USER', 'Username to login to Nessus') do |username|
options[:username] = username
end
opts.on('-p', '--password PASSWD', 'Password to login to Nessus') do |passwd|
options[:passwd] = passwd
end
opts.on('-s', '--server SERVER', 'Server name (localhost is default)') do |server|
options[:server] = server
end
opts.on('-l', '--policy POLICY', 'Policy to scan with' ) do |policy|
options[:policy] = policy
end
opts.on('-t', '--target TARGET', 'Target to scan') do |target|
options[:target] = target
end
opts.on('-n', '--name NAME', 'Scan name') do |name|
options[:name] = name
end
opts.on('-h', '--help', 'Display help') do
puts opts
exit
end
opts.on('-f', '--file INFILE', 'File of hosts to scan') do |file|
options[:file] = file
end
opts.on('--show-policies', 'Shows Server Policies') do
options[:showpol] = true
end
opts.on('--show-reports', 'Shows Server Reports') do
options[:showrpt] = true
end
opts.on('-g', '--get-report RPTID', 'Download Report in Nessus V2 format.') do |rpt|
options[:rptid] = rpt
end
opts.on('-o', '--out FILE', 'Optional filename to output to.') do |out|
options[:out] = out
end
opts.on('-c', '--check', 'Checks the status of a report supplied with -g') do
options[:check] = true
end
opts.on('--port PORT', 'Optional portnumber to connect to Nessus. Defaults to 8834.') do |port|
options[:port] = port || "8834"
end
case ARGV.length
when 0
puts opts
exit
end
@fopts = opts
end
optparse.parse!
if !options[:port]
options[:port] = "8834"
end
if !options[:cfile]
if !(options[:username] and options[:passwd] and options[:server])
puts
puts("**[FAIL]** Missing Arguments")
puts
puts @fopts
exit
end
end
# Our Connection Class
class NessusConnection
def initialize(user, pass, server, port)
@username = user
@passwd = pass
@server = server
@nurl = "https://#{@server}:" + port + "/"
# @nurl = "https://#{@server}:8834/"
@token = nil
@status = nil
end
def connect(uri, post_data)
url = URI.parse(@nurl + uri)
request = Net::HTTP::Post.new( url.path )
request.set_form_data(post_data)
if not defined? @https
@https = Net::HTTP.new( url.host, url.port )
@https.use_ssl = true
@https.verify_mode = OpenSSL::SSL::VERIFY_NONE
end
begin
res = @https.request(request)
rescue
puts("error connecting to server: #{@nurl} with URI: #{uri}")
exit
end
return res.body
end
end
def show_policy(options)
uri = "scan/list"
post_data = { "token" => @token }
stuff = @n.connect(uri, post_data)
docxml = REXML::Document.new(stuff)
policies=Array.new
docxml.elements.each('/reply/contents/policies/policies/policy') { |policy|
entry=Hash.new
entry['id']=policy.elements['policyID'].text
entry['name']=policy.elements['policyName'].text
if policy.elements['policyComments'] == nil
entry['comment']=" "
else
entry['comment']=policy.elements['policyComments'].text
end
policies.push(entry)
}
puts("ID\tName")
policies.each do |policy|
puts("#{policy['id']}\t#{policy['name']}")
end
end
def login(options)
uri = "login"
post_data = { "login" => options[:username], "password" => options[:passwd] }
#p post_data
stuff = @n.connect(uri, post_data)
docxml = REXML::Document.new(stuff)
if docxml == ''
@token=''
else
begin
@status = docxml.root.elements['status'].text
@token = docxml.root.elements['contents'].elements['token'].text
@name = docxml.root.elements['contents'].elements['user'].elements['name'].text
@admin = docxml.root.elements['contents'].elements['user'].elements['admin'].text
rescue
puts "error #{@status}"
sleep 60
exit
end
end
end
def logout(options)
uri = "logout"
post_data = { "token" => @token }
stuff = @n.connect(uri, post_data)
end
def show_reports(options)
uri = "report/list"
post_data = { "token" => @token }
stuff = @n.connect(uri, post_data)
docxml = REXML::Document.new(stuff)
reports=Array.new
docxml.elements.each('/reply/contents/reports/report') {|report|
entry=Hash.new
entry['id']=report.elements['name'].text if report.elements['name']
entry['name']=report.elements['readableName'].text if report.elements['readableName']
entry['status']=report.elements['status'].text if report.elements['status']
entry['timestamp']=report.elements['timestamp'].text if report.elements['timestamp']
reports.push(entry)
}
puts("ID\tName")
reports.sort! { |a,b| b['timestamp'] <=> a['timestamp'] }
reports.each do |report|
t = Time.at(report['timestamp'].to_i)
puts("#{report['id']}\t#{report['name']}\t\t#{t.strftime("%H:%M %b %d %Y")}")
end
end
def get_report(options)
status = nil
uri = "scan/list"
post_data = { "token" => @token }
stuff = @n.connect(uri, post_data)
begin
docxml = REXML::Document.new(stuff)
docxml.elements.each('/reply/contents/scans/scanList/scan') {|scan|
if scan.elements['uuid'].text == options[:rptid]
@status = scan.elements['status'].text
@now = scan.elements['completion_current'].text
@total = scan.elements['completion_total'].text
end
}
rescue
# puts ("Warning: cannot get scan status")
end
puts("#{@status}|#{@now}|#{@total}")
if @status != "OK"
#puts("Scan it not completed, cannot download")
exit
end
stuff = nil
uri = "file/report/download"
post_data = { "token" => @token, "report" => options[:rptid] }
stuff = @n.connect(uri, post_data)
if options[:rptid]
if options[:out]
File.open("#{options[:out]}.nessus", 'w') {|f| f.write(stuff) }
exit
else
File.open("#{options[:rptid]}.nessus", 'w') {|f| f.write(stuff) }
exit
end
else
puts("Error: No Report Specified")
end
end
@n = NessusConnection.new(options[:username], options[:passwd], options[:server], options[:port])
if options[:showpol]
login(options)
show_policy(options)
logout(options)
exit
end
if options[:showrpt]
login(options)
show_reports(options)
logout(options)
exit
end
if options[:rptid]
login(options)
get_report(options)
logout(options)
exit
end
login(options)
##verify policy
uri = "scan/list"
pid = options[:policy]
post_data = { "token" => @token }
stuff = @n.connect(uri, post_data)
docxml = REXML::Document.new(stuff)
policies=Array.new
docxml.elements.each('/reply/contents/policies/policies/policy') { |policy|
entry=Hash.new
entry['id']=policy.elements['policyID'].text
entry['name']=policy.elements['policyName'].text
if policy.elements['policyComments'] == nil
entry['comment']=" "
else
entry['comment']=policy.elements['policyComments'].text
end
policies.push(entry)
}
match = nil
policies.each {|p|
if p['id'].to_i == pid.to_i
match = pid
next
end
}
if match.nil?
puts("No Matching Policy ID: #{pid}")
exit
end
tgts = ""
if options[:file]
File.open("#{options[:file]}", "r") do |tgtf|
while (line = tgtf.gets)
tgts << line
tgts << ","
end
end
tgts.chop!
else
tgts = options[:target]
end
#start scan
uri = "scan/new"
post_data = { "token" => @token, "policy_id" => options[:policy], "scan_name" => options[:name], "target" => tgts }
stuff = @n.connect(uri, post_data)
docxml = REXML::Document.new(stuff)
uuid=docxml.root.elements['contents'].elements['scan'].elements['uuid'].text
puts("#{uuid}")
| 27.606154 | 115 | 0.604882 |
281de5bdc28360d3e637d1c30eb46a2f24330c4b | 2,221 | class Caddy < Formula
desc "Powerful, enterprise-ready, open source web server with automatic HTTPS"
homepage "https://caddyserver.com/"
url "https://github.com/caddyserver/caddy/archive/v2.4.4.tar.gz"
sha256 "0ea7b65406c77b2ce88cdf496e82b70838c78305659fa5c891ef004dfabcc17a"
license "Apache-2.0"
head "https://github.com/caddyserver/caddy.git", branch: "master"
bottle do
sha256 cellar: :any_skip_relocation, arm64_big_sur: "1f4dd7deb1ee1c337d8bee3e91c522ada5f86bd677113079ff6ce087c915e581"
sha256 cellar: :any_skip_relocation, big_sur: "931f9b62c50c28f28b930bdfd830323834260ad397d78bbdf3609d220dc60bf3"
sha256 cellar: :any_skip_relocation, catalina: "931f9b62c50c28f28b930bdfd830323834260ad397d78bbdf3609d220dc60bf3"
sha256 cellar: :any_skip_relocation, mojave: "931f9b62c50c28f28b930bdfd830323834260ad397d78bbdf3609d220dc60bf3"
sha256 cellar: :any_skip_relocation, x86_64_linux: "8c0bef614ad308b3828c08b74e04f5605a4add5d85904443c13f632ad9007908"
end
depends_on "go" => :build
resource "xcaddy" do
url "https://github.com/caddyserver/xcaddy/archive/v0.1.9.tar.gz"
sha256 "399880f59bf093394088cf2d802b19e666377aea563b7ada5001624c489b62c9"
end
def install
revision = build.head? ? version.commit : "v#{version}"
resource("xcaddy").stage do
system "go", "run", "cmd/xcaddy/main.go", "build", revision, "--output", bin/"caddy"
end
end
service do
run [opt_bin/"caddy", "run", "--config", etc/"Caddyfile"]
keep_alive true
error_log_path var/"log/caddy.log"
log_path var/"log/caddy.log"
end
test do
port1 = free_port
port2 = free_port
(testpath/"Caddyfile").write <<~EOS
{
admin 127.0.0.1:#{port1}
}
http://127.0.0.1:#{port2} {
respond "Hello, Caddy!"
}
EOS
fork do
exec bin/"caddy", "run", "--config", testpath/"Caddyfile"
end
sleep 2
assert_match "\":#{port2}\"",
shell_output("curl -s http://127.0.0.1:#{port1}/config/apps/http/servers/srv0/listen/0")
assert_match "Hello, Caddy!", shell_output("curl -s http://127.0.0.1:#{port2}")
assert_match version.to_s, shell_output("#{bin}/caddy version")
end
end
| 34.169231 | 122 | 0.70824 |
5d11646c85f98539921a513e72b6fd81bbb27768 | 7,492 | # Copyright (c) 2016, 2019, Oracle and/or its affiliates. All rights reserved.
require 'date'
# rubocop:disable Lint/UnneededCopDisableDirective, Metrics/LineLength
module OCI
# A base request type containing common criteria for searching for resources.
# This class has direct subclasses. If you are using this class as input to a service operations then you should favor using a subclass over the base class
class ResourceSearch::Models::SearchDetails
MATCHING_CONTEXT_TYPE_ENUM = [
MATCHING_CONTEXT_TYPE_NONE = 'NONE'.freeze,
MATCHING_CONTEXT_TYPE_HIGHLIGHTS = 'HIGHLIGHTS'.freeze
].freeze
# **[Required]** The type of SearchDetails, whether `FreeText` or `Structured`.
# @return [String]
attr_accessor :type
# The type of matching context returned in the response. If you specify `HIGHLIGHTS`, then the service will highlight fragments in its response. (See ResourceSummary.searchContext and SearchContext for more information.) The default setting is `NONE`.
#
# @return [String]
attr_reader :matching_context_type
# Attribute mapping from ruby-style variable name to JSON key.
def self.attribute_map
{
# rubocop:disable Style/SymbolLiteral
'type': :'type',
'matching_context_type': :'matchingContextType'
# rubocop:enable Style/SymbolLiteral
}
end
# Attribute type mapping.
def self.swagger_types
{
# rubocop:disable Style/SymbolLiteral
'type': :'String',
'matching_context_type': :'String'
# rubocop:enable Style/SymbolLiteral
}
end
# rubocop:disable Metrics/CyclomaticComplexity, Layout/EmptyLines, Metrics/PerceivedComplexity, Metrics/AbcSize
# Given the hash representation of a subtype of this class,
# use the info in the hash to return the class of the subtype.
def self.get_subtype(object_hash)
type = object_hash[:'type'] # rubocop:disable Style/SymbolLiteral
return 'OCI::ResourceSearch::Models::StructuredSearchDetails' if type == 'Structured'
return 'OCI::ResourceSearch::Models::FreeTextSearchDetails' if type == 'FreeText'
# TODO: Log a warning when the subtype is not found.
'OCI::ResourceSearch::Models::SearchDetails'
end
# rubocop:enable Metrics/CyclomaticComplexity, Layout/EmptyLines, Metrics/PerceivedComplexity, Metrics/AbcSize
# rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
# rubocop:disable Metrics/MethodLength, Layout/EmptyLines, Style/SymbolLiteral
# Initializes the object
# @param [Hash] attributes Model attributes in the form of hash
# @option attributes [String] :type The value to assign to the {#type} property
# @option attributes [String] :matching_context_type The value to assign to the {#matching_context_type} property
def initialize(attributes = {})
return unless attributes.is_a?(Hash)
# convert string to symbol for hash key
attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
self.type = attributes[:'type'] if attributes[:'type']
self.matching_context_type = attributes[:'matchingContextType'] if attributes[:'matchingContextType']
raise 'You cannot provide both :matchingContextType and :matching_context_type' if attributes.key?(:'matchingContextType') && attributes.key?(:'matching_context_type')
self.matching_context_type = attributes[:'matching_context_type'] if attributes[:'matching_context_type']
end
# rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
# rubocop:enable Metrics/MethodLength, Layout/EmptyLines, Style/SymbolLiteral
# Custom attribute writer method checking allowed values (enum).
# @param [Object] matching_context_type Object to be assigned
def matching_context_type=(matching_context_type)
raise "Invalid value for 'matching_context_type': this must be one of the values in MATCHING_CONTEXT_TYPE_ENUM." if matching_context_type && !MATCHING_CONTEXT_TYPE_ENUM.include?(matching_context_type)
@matching_context_type = matching_context_type
end
# rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity, Layout/EmptyLines
# Checks equality by comparing each attribute.
# @param [Object] other the other object to be compared
def ==(other)
return true if equal?(other)
self.class == other.class &&
type == other.type &&
matching_context_type == other.matching_context_type
end
# rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity, Layout/EmptyLines
# @see the `==` method
# @param [Object] other the other object to be compared
def eql?(other)
self == other
end
# rubocop:disable Metrics/AbcSize, Layout/EmptyLines
# Calculates hash code according to all attributes.
# @return [Fixnum] Hash code
def hash
[type, matching_context_type].hash
end
# rubocop:enable Metrics/AbcSize, Layout/EmptyLines
# rubocop:disable Metrics/AbcSize, Layout/EmptyLines
# Builds the object from hash
# @param [Hash] attributes Model attributes in the form of hash
# @return [Object] Returns the model itself
def build_from_hash(attributes)
return nil unless attributes.is_a?(Hash)
self.class.swagger_types.each_pair do |key, type|
if type =~ /^Array<(.*)>/i
# check to ensure the input is an array given that the the attribute
# is documented as an array but the input is not
if attributes[self.class.attribute_map[key]].is_a?(Array)
public_method("#{key}=").call(
attributes[self.class.attribute_map[key]]
.map { |v| OCI::Internal::Util.convert_to_type(Regexp.last_match(1), v) }
)
end
elsif !attributes[self.class.attribute_map[key]].nil?
public_method("#{key}=").call(
OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]])
)
end
# or else data not found in attributes(hash), not an issue as the data can be optional
end
self
end
# rubocop:enable Metrics/AbcSize, Layout/EmptyLines
# Returns the string representation of the object
# @return [String] String presentation of the object
def to_s
to_hash.to_s
end
# Returns the object in the form of hash
# @return [Hash] Returns the object in the form of hash
def to_hash
hash = {}
self.class.attribute_map.each_pair do |attr, param|
value = public_method(attr).call
next if value.nil? && !instance_variable_defined?("@#{attr}")
hash[param] = _to_hash(value)
end
hash
end
private
# Outputs non-array value in the form of hash
# For object, use to_hash. Otherwise, just return the value
# @param [Object] value Any valid value
# @return [Hash] Returns the value in the form of hash
def _to_hash(value)
if value.is_a?(Array)
value.compact.map { |v| _to_hash(v) }
elsif value.is_a?(Hash)
{}.tap do |hash|
value.each { |k, v| hash[k] = _to_hash(v) }
end
elsif value.respond_to? :to_hash
value.to_hash
else
value
end
end
end
end
# rubocop:enable Lint/UnneededCopDisableDirective, Metrics/LineLength
| 38.420513 | 255 | 0.696343 |
abaf5ec0af46027c57bb7ed9a10f15901f3f3b24 | 39 | # typed: strong
module UsersHelper
end
| 9.75 | 18 | 0.794872 |
03f01d2e5c0c0595c72691743a7b664f527245dc | 107 | Fabricator :link do
name { Faker::Company.name }
url { "http://#{Faker::Internet.domain_name}" }
end | 26.75 | 51 | 0.654206 |
212bbf564912da5d53a86c5ec59b430782561e1a | 5,285 | require 'spec_helper'
module ROF::Translators
describe "translate CSV" do
it "requires rows to have an owner and type" do
s = %q{type,owner
Work,
}
expect{CsvToRof.call(s)}.to raise_error(ROF::Translators::CsvToRof::MissingOwnerOrType)
end
it "deocdes the access field into rights" do
s = %q{type,owner,access
Work,user1,"private;edit=user2,user3"
}
rof = CsvToRof.call(s)
expect(rof).to eq([{
"type" => "Work",
"owner" => "user1",
"rights" => {"edit" => ["user1", "user2", "user3"]},
"properties-meta" => {"mime-type" => "text/xml"},
"properties" => "<fields><depositor>batch_ingest</depositor>\n<owner>user1</owner>\n</fields>\n"
}])
end
it "puts metadata into substructure" do
s = %q{type,owner,dc:title,foaf:name
Work,user1,"Q, A Letter",Jane Smith|Zander
}
rof = CsvToRof.call(s)
expect(rof).to eq([{
"type" => "Work",
"owner" => "user1",
"rights" => {"edit" => ["user1"]},
"metadata" => {
"@context" => ROF::RdfContext,
"dc:title" => "Q, A Letter",
"foaf:name" => ["Jane Smith", "Zander"]},
"properties-meta" => {"mime-type" => "text/xml"},
"properties" => "<fields><depositor>batch_ingest</depositor>\n<owner>user1</owner>\n</fields>\n"
}])
end
it "renames curate_id to pid" do
s = %q{type,owner,curate_id
Work,user1,abcdefg
}
rof = CsvToRof.call(s)
expect(rof).to eq([{
"type" => "Work",
"owner" => "user1",
"pid" => "abcdefg",
"rights" => {"edit" => ["user1"]},
"properties-meta" => {"mime-type" => "text/xml"},
"properties" => "<fields><depositor>batch_ingest</depositor>\n<owner>user1</owner>\n</fields>\n"
}])
end
it "strips space around pipes" do
s = %q{type,owner,dc:title,foaf:name
Work,user1,"Q, A Letter",Jane Smith | Zander
}
rof = CsvToRof.call(s)
expect(rof).to eq([{
"type" => "Work",
"owner" => "user1",
"rights" => {"edit" => ["user1"]},
"metadata" => {
"@context" => ROF::RdfContext,
"dc:title" => "Q, A Letter",
"foaf:name" => ["Jane Smith", "Zander"]},
"properties" => "<fields><depositor>batch_ingest</depositor>\n<owner>user1</owner>\n</fields>\n",
"properties-meta" => {"mime-type" => "text/xml"}
}])
end
it "handles follow-on generic files" do
s = %q{type,owner,dc:title,files
Work,user1,"Q, A Letter",thumb
+,user1,,extra file.txt
}
rof = CsvToRof.call(s)
expect(rof).to eq([{
"type" => "Work",
"owner" => "user1",
"rights" => {"edit" => ["user1"]},
"metadata" => {
"@context" => ROF::RdfContext,
"dc:title" => "Q, A Letter"},
"files" => [
"thumb",
{
"type" => "+",
"owner" => "user1",
"files" => ["extra file.txt"],
"rights" => {"edit" => ["user1"]}
}],
"properties-meta" => {"mime-type" => "text/xml"},
"properties" => "<fields><depositor>batch_ingest</depositor>\n<owner>user1</owner>\n</fields>\n"
}])
end
it "raises an error if a follow-on file has no preceeding work" do
s = %q{type,owner,dc:title,files
+,user1,,extra file.txt
}
expect {CsvToRof.call(s)}.to raise_error(ROF::Translators::CsvToRof::NoPriorWork)
end
it "decodes the double caret encoding correctly" do
s = %q{type,owner,dc:title,dc:contributor
Work,user1,"a title","^^dc:contributor Jane Doe^^ms:role Committee Member"
}
rof = CsvToRof.call(s)
expect(rof).to eq([{
"type" => "Work",
"owner" => "user1",
"rights" => {"edit" => ["user1"]},
"metadata" => {
"dc:title" => "a title",
"dc:contributor" => {
"dc:contributor" => "Jane Doe",
"ms:role" => "Committee Member"
},
"@context" => ROF::RdfContext
},
"properties-meta" => {"mime-type" => "text/xml"},
"properties" => "<fields><depositor>batch_ingest</depositor>\n<owner>user1</owner>\n</fields>\n"
}])
end
it "decodes multiple values of double carets correctly" do
s = %q{type,owner,dc:title,dc:contributor
Work,user1,"a title","^^name Jane Doe^^ms:role Committee Member|^^name Hugo Easton Whitman, III^^ms:role Research Advisor"
}
rof = CsvToRof.call(s)
expect(rof).to eq([{
"type" => "Work",
"owner" => "user1",
"rights" => {"edit" => ["user1"]},
"properties-meta" => {"mime-type" => "text/xml"},
"properties" => "<fields><depositor>batch_ingest</depositor>\n<owner>user1</owner>\n</fields>\n",
"metadata" => {
"dc:title" => "a title",
"dc:contributor" => [{
"name" => "Jane Doe",
"ms:role" => "Committee Member"
},{
"name" => "Hugo Easton Whitman, III",
"ms:role" => "Research Advisor"
}],
"@context" => ROF::RdfContext
}
}])
end
end
end
| 33.238994 | 128 | 0.508231 |
1c01d9bf7f6cf2aec04a0483fbfd42ac96335e9a | 1,433 | module PageObjects
module Pages
module Admin
module Cases
class NewFOIPage < PageObjects::Pages::Base
set_url '/admin/cases/new/foi'
sections :notices, '.notice-summary' do
element :heading, '.notice-summary-heading'
end
section :page_heading,
PageObjects::Sections::PageHeadingSection, '.page-heading'
element :case_type_foi_standard, '#case_foi_type_casefoistandard'
element :full_name, '#case_foi_name'
element :email, '#case_foi_email'
element :address, '#case_foi_postal_address'
element :type_of_requester, :xpath,
'//fieldset[contains(.,"Type of requester")]'
element :subject, '#case_foi_subject'
element :full_request, '#case_foi_message'
element :received_date, '#case_foi_received_date'
element :created_at, '#case_foi_created_at'
element :flag_for_disclosure_specialists,
'#case_foi_flagged_for_disclosure_specialist_clearance'
element :flag_for_press_office,
'#case_foi_flagged_for_press_office_clearance'
element :flag_for_private_office,
'#case_foi_flagged_for_private_office_clearance'
element :target_state, '#case_foi_target_state'
element :submit_button, '.button'
end
end
end
end
end
| 34.119048 | 76 | 0.636427 |
79c475bbc898f371482144480158bcc10478907d | 111 | require 'resque/tasks'
ENV["QUEUE"] = "*"
task "resque:setup" => :environment
task "jobs:work" => "resque:work" | 27.75 | 35 | 0.666667 |
1cb13a362d95b51b0ae4eb88a2675a054e318ced | 928 | # -*- encoding: utf-8 -*-
$:.push File.expand_path("../lib", __FILE__)
require "jekyll-minimagick/version"
Gem::Specification.new do |s|
s.name = "jekyll-minimagick"
s.version = Jekyll::Minimagick::VERSION
s.platform = Gem::Platform::RUBY
s.authors = ["Roger López"]
s.email = ["[email protected]"]
s.homepage = "http://github.com/zroger/jekyll-minimagick"
s.summary = %q{MiniMagick integration for Jekyll}
s.description = %q{Use MiniMagick to crop and resize images in your Jekyll project.}
s.rubyforge_project = "jekyll-minimagick"
s.files = `git ls-files`.split("\n")
s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
s.require_paths = ["lib"]
s.add_runtime_dependency('jekyll', [">= 0.10.0"])
s.add_runtime_dependency('mini_magick', [">= 3.3"])
end
| 37.12 | 86 | 0.639009 |
6a5e2c3978815d111b1e889c14e5a1e859def844 | 1,556 |
lib = File.expand_path("../lib", __FILE__)
$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
require "link_to/version"
Gem::Specification.new do |spec|
spec.name = "link_to"
spec.version = LinkTo::VERSION
spec.authors = ["yamitake"]
spec.email = ["[email protected]"]
spec.summary = %q{Make the link_to method easier to use}
spec.description = %q{Make the link_to method easier to use. We provide a method group suitable for actual development, such as attaching `active` to the class attribute common to web applications.}
spec.homepage = "https://github.com/yamitake/link_to"
spec.license = "MIT"
# Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
# to allow pushing to a single host or delete this section to allow pushing to any host.
if spec.respond_to?(:metadata)
spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
else
raise "RubyGems 2.0 or newer is required to protect against " \
"public gem pushes."
end
spec.files = `git ls-files -z`.split("\x0").reject do |f|
f.match(%r{^(test|spec|features)/})
end
spec.bindir = "exe"
spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
spec.require_paths = ["lib"]
spec.add_development_dependency "bundler", "~> 1.16"
spec.add_development_dependency "rake", "~> 10.0"
spec.add_development_dependency "rails", [">= 3.2.11"]
spec.add_development_dependency "rspec", "~> 3.0"
end
| 40.947368 | 202 | 0.67545 |
61ca5206ff721e5553ecb2c70cad059bd72fcb23 | 120 | class Current < ActiveSupport::CurrentAttributes
# makes Current.user accessible in view files.
attribute :user
end
| 24 | 48 | 0.791667 |
e834f73d845f409d02670281c129865cc26391b7 | 525 | require "test_helpers"
class TestTags < RSpecQTest
def test_inclusion_filter
queue = exec_build("tagged_suite", "--tag=slow")
assert_processed_jobs [
"./spec/tagged_spec.rb",
], queue
assert_equal 1, queue.example_count
end
def test_exclusion_filter
queue = exec_build("tagged_suite", "--tag=~slow")
assert_equal 2, queue.example_count
end
def test_mixed_filter
queue = exec_build("tagged_suite", "--tag=~slow --tag=~fast")
assert_equal 1, queue.example_count
end
end
| 20.192308 | 65 | 0.699048 |
338c856588e3b6a0977d9a34db63fb0ab056a975 | 377 | class SessionsController < ApplicationController
def new; end
def create
user = User.find_by_username(params[:username])
if user
session[:user_id] = user.id
redirect_to root_path
else
render 'new'
end
end
def destroy
session[:user_id] = nil
redirect_to root_path flash[:success] = 'You have succesfully logged out'
end
end
| 19.842105 | 77 | 0.681698 |
082be1f7e1165915d411f86d6c57e6d9d78fc523 | 5,183 | # frozen_string_literal: true
module API
class Wikis < ::API::Base
helpers ::API::Helpers::WikisHelpers
feature_category :wiki
helpers do
attr_reader :container
params :common_wiki_page_params do
optional :format,
type: String,
values: Wiki::VALID_USER_MARKUPS.keys.map(&:to_s),
default: 'markdown',
desc: 'Format of a wiki page. Available formats are markdown, rdoc, asciidoc and org'
end
end
WIKI_ENDPOINT_REQUIREMENTS = API::NAMESPACE_OR_PROJECT_REQUIREMENTS.merge(slug: API::NO_SLASH_URL_PART_REGEX)
::API::Helpers::WikisHelpers.wiki_resource_kinds.each do |container_resource|
resource container_resource, requirements: WIKI_ENDPOINT_REQUIREMENTS do
after_validation do
@container = Gitlab::Lazy.new { find_container(container_resource) }
end
desc 'Get a list of wiki pages' do
success Entities::WikiPageBasic
end
params do
optional :with_content, type: Boolean, default: false, desc: "Include pages' content"
end
get ':id/wikis', urgency: :low do
authorize! :read_wiki, container
entity = params[:with_content] ? Entities::WikiPage : Entities::WikiPageBasic
options = {
with: entity,
current_user: current_user
}
present container.wiki.list_pages(load_content: params[:with_content]), options
end
desc 'Get a wiki page' do
success Entities::WikiPage
end
params do
requires :slug, type: String, desc: 'The slug of a wiki page'
optional :version, type: String, desc: 'The version hash of a wiki page'
optional :render_html, type: Boolean, default: false, desc: 'Render content to HTML'
end
get ':id/wikis/:slug', urgency: :low do
authorize! :read_wiki, container
options = {
with: Entities::WikiPage,
render_html: params[:render_html],
current_user: current_user
}
present wiki_page(params[:version]), options
end
desc 'Create a wiki page' do
success Entities::WikiPage
end
params do
requires :title, type: String, desc: 'Title of a wiki page'
requires :content, type: String, desc: 'Content of a wiki page'
use :common_wiki_page_params
end
post ':id/wikis' do
authorize! :create_wiki, container
response = WikiPages::CreateService.new(container: container, current_user: current_user, params: params).execute
page = response.payload[:page]
if response.success?
present page, with: Entities::WikiPage
else
render_validation_error!(page)
end
end
desc 'Update a wiki page' do
success Entities::WikiPage
end
params do
optional :title, type: String, desc: 'Title of a wiki page'
optional :content, type: String, desc: 'Content of a wiki page'
use :common_wiki_page_params
at_least_one_of :content, :title, :format
end
put ':id/wikis/:slug' do
authorize! :create_wiki, container
response = WikiPages::UpdateService
.new(container: container, current_user: current_user, params: params)
.execute(wiki_page)
page = response.payload[:page]
if response.success?
present page, with: Entities::WikiPage
else
render_validation_error!(page)
end
end
desc 'Delete a wiki page'
params do
requires :slug, type: String, desc: 'The slug of a wiki page'
end
delete ':id/wikis/:slug' do
authorize! :admin_wiki, container
response = WikiPages::DestroyService
.new(container: container, current_user: current_user)
.execute(wiki_page)
if response.success?
no_content!
else
unprocessable_entity!(response.message)
end
end
desc 'Upload an attachment to the wiki repository' do
detail 'This feature was introduced in GitLab 11.3.'
success Entities::WikiAttachment
end
params do
requires :file, types: [Rack::Multipart::UploadedFile, ::API::Validations::Types::WorkhorseFile], desc: 'The attachment file to be uploaded'
optional :branch, type: String, desc: 'The name of the branch'
end
post ":id/wikis/attachments" do
authorize! :create_wiki, container
result = ::Wikis::CreateAttachmentService.new(
container: container,
current_user: current_user,
params: commit_params(declared_params(include_missing: false))
).execute
if result[:status] == :success
status(201)
present result[:result], with: Entities::WikiAttachment
else
render_api_error!(result[:message], 400)
end
end
end
end
end
end
| 32.597484 | 150 | 0.60274 |
5d43f8dc98052e172aa8c89badbe4ed535d3f193 | 124 | RSpec.describe Threadfix::Cli do
it "has a version number" do
expect(Threadfix::Cli::VERSION).not_to be nil
end
end
| 20.666667 | 49 | 0.725806 |
910c4c0bd394d598e89aed91e0d961bd4e425887 | 250 | module Admin
module V1
module Types
class BaseObject < GraphQL::Schema::Object
edge_type_class(Types::BaseEdge)
connection_type_class(Types::BaseConnection)
field_class Types::BaseField
end
end
end
end
| 20.833333 | 52 | 0.676 |
38b636e4e5a36c9bf5272f2f30f8246bd4b03ec8 | 3,071 | # frozen_string_literal: true
module Gitlab
module Diff
module FileCollection
class Base
include Gitlab::Utils::StrongMemoize
attr_reader :project, :diff_options, :diff_refs, :fallback_diff_refs, :diffable
delegate :count, :size, :real_size, to: :raw_diff_files
def self.default_options
::Commit.max_diff_options.merge(ignore_whitespace_change: false, expanded: false, include_stats: true)
end
def initialize(diffable, project:, diff_options: nil, diff_refs: nil, fallback_diff_refs: nil)
diff_options = self.class.default_options.merge(diff_options || {})
@diffable = diffable
@include_stats = diff_options.delete(:include_stats)
@project = project
@diff_options = diff_options
@diff_refs = diff_refs
@fallback_diff_refs = fallback_diff_refs
@repository = project.repository
end
def diffs
@diffs ||= diffable.raw_diffs(diff_options)
end
def diff_files
raw_diff_files
end
def raw_diff_files
@raw_diff_files ||= diffs.decorate! { |diff| decorate_diff!(diff) }
end
def diff_file_paths
diff_files.map(&:file_path)
end
def pagination_data
{
current_page: nil,
next_page: nil,
total_pages: nil
}
end
# This mutates `diff_files` lines.
def unfold_diff_files(positions)
positions_grouped_by_path = positions.group_by { |position| position.file_path }
diff_files.each do |diff_file|
positions = positions_grouped_by_path.fetch(diff_file.file_path, [])
positions.each { |position| diff_file.unfold_diff_lines(position) }
end
end
def diff_file_with_old_path(old_path)
diff_files.find { |diff_file| diff_file.old_path == old_path }
end
def diff_file_with_new_path(new_path)
diff_files.find { |diff_file| diff_file.new_path == new_path }
end
def clear_cache
# No-op
end
def write_cache
# No-op
end
private
def diff_stats_collection
strong_memoize(:diff_stats) do
# There are scenarios where we don't need to request Diff Stats,
# when caching for instance.
next unless @include_stats
next unless diff_refs
@repository.diff_stats(diff_refs.base_sha, diff_refs.head_sha)
end
end
def decorate_diff!(diff)
return diff if diff.is_a?(File)
stats = diff_stats_collection&.find_by_path(diff.new_path)
Gitlab::Diff::File.new(diff,
repository: project.repository,
diff_refs: diff_refs,
fallback_diff_refs: fallback_diff_refs,
stats: stats)
end
end
end
end
end
| 28.700935 | 112 | 0.590361 |
79c7251f01af27cb4d9d12b722a96e84148e3236 | 51 | describe :string_unpack_taint, shared: true do
end
| 17 | 46 | 0.823529 |
f737f3665f87e20c9a79120adc4cfe5c2dfa5130 | 855 | ActiveAdmin.register BadgeClaim do
menu priority: 99
permit_params :badge_id, :user_id
filter :badge
action_item :create_many, only: :index do
link_to 'Create Many', admin_utilities_path
end
form do |f|
f.semantic_errors(*f.object.errors.keys)
f.inputs do
f.input :badge
f.input :user
end
f.actions
end
index do
selectable_column
column :badge
column :user
column :redemption_code
column 'claim link' do |badge_claim|
claim_link badge_claim
end
column :created_at
column :updated_at
actions
end
show do |f|
attributes_table do
row :badge do |b|
b.badge.name
end
row :user do |b|
if b.user.nil?
nil
else
b.user.display_name
end
end
row :redemption_code
end
end
end
| 17.44898 | 47 | 0.616374 |
3397b657c88f5fa0a62e5ed6950cc47357cb110b | 1,401 | class ApplicationMailbox < ActionMailbox::Base
# Last part is the regex for the UUID
# Eg: email should be something like : [email protected]
REPLY_EMAIL_USERNAME_PATTERN = /^reply\+([0-9a-f]{8}\b-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-\b[0-9a-f]{12})$/i
def self.reply_mail?
proc do |inbound_mail_obj|
is_a_reply_email = false
inbound_mail_obj.mail.to&.each do |email|
username = email.split('@')[0]
match_result = username.match(REPLY_EMAIL_USERNAME_PATTERN)
if match_result
is_a_reply_email = true
break
end
end
is_a_reply_email
end
end
def self.support_mail?
proc do |inbound_mail_obj|
is_a_support_email = false
inbound_mail_obj.mail.to&.each do |email|
channel = Channel::Email.find_by('lower(email) = ? OR lower(forward_to_email) = ?', email.downcase, email.downcase)
if channel.present?
is_a_support_email = true
break
end
end
is_a_support_email
end
end
def self.catch_all_mail?
proc { |_mail| true }
end
# routing should be defined below the referenced procs
# routes as a reply to existing conversations
routing(reply_mail? => :reply)
# routes as a new conversation in email channel
routing(support_mail? => :support)
routing(catch_all_mail? => :default)
end
| 29.808511 | 123 | 0.66167 |
28f12288b8fa1e3b323b44b1397b4ce27803da7f | 4,711 | # frozen_string_literal: true
module Blackjack
class Console
def self.print_logo
logo = <<~LOGO
===========================================================================
888888b. 888 888 d8b 888
888 "88b 888 888 Y8P 888
888 .88P 888 888 888
8888888K. 888 8888b. .d8888b 888 888 8888 8888b. .d8888b 888 888
888 "Y88b 888 "88b d88P" 888 .88P "888 "88b d88P" 888 .88P
888 888 888 .d888888 888 888888K 888 .d888888 888 888888K
888 d88P 888 888 888 Y88b. 888 "88b 888 888 888 Y88b. 888 "88b
8888888P" 888 "Y888888 "Y8888P 888 888 888 "Y888888 "Y8888P 888 888
============================================ 888 ==========================
d88P
888P"
LOGO
puts logo
end
def self.new_line
puts
end
def self.print_message(message)
puts message
end
def self.print_bordered_message(message, length: message.length, align: align)
block_message = format_messages(messages: [message], length: length, align: align)
print_horizontal([block_message])
end
def self.print_errors(errors)
errors.map do |error|
print_bordered_message("Error: #{error.message}", length: 69, align: :ljust)
end
end
def self.print_game_board
clear_screen
print_logo
new_line
end
def self.print_current_state(game)
round_text = [
"Round ##{game.round_number}",
"Current bet: #{game.round.total_bet}"
]
round_info = format_messages(messages: round_text, length: 32)
player_text = [
"Player name: #{game.player.name}",
"Player money: #{game.player.total_money}"
]
player_info = format_messages(messages: player_text, length: 32)
print_horizontal([round_info, player_info])
end
def self.print_cards_state(game)
dealer_cards_message = "Dealer's cards [points: #{game.round.dealer_points}]:"
dealer_cards_info = format_messages(messages: [dealer_cards_message], length: 69)
print_horizontal([dealer_cards_info])
print_cards(game.round.dealer_cards)
player_cards_message = "Your cards [points: #{game.round.player_points}]:"
player_cards_info = format_messages(messages: [player_cards_message], length: 69)
print_horizontal([player_cards_info])
print_cards(game.round.player_cards)
end
def self.print_result(game)
result_message = "#{game.round.status.capitalize}"
result_info = format_messages(messages: [result_message], length: 69, align: :center)
print_horizontal([result_info])
bets_message = "Your bets: #{game.round.total_bet}"
bets_info = format_messages(messages: [bets_message], length: 32)
winning_message = "Your winning: #{game.round.winning}"
winning_info = format_messages(messages: [winning_message], length: 32)
print_horizontal([bets_info, winning_info])
end
def self.print_cards(cards)
formatted_cards = cards.map { |card| format_card(card) }
print_horizontal(formatted_cards)
end
def self.print_horizontal(items)
lines_count = items.map(&:count).max
line_idents = [''] * lines_count
lines = items.reduce(line_idents) do |result, item|
result.zip(item).map { |line_parts| line_parts.join(' ') }
end
puts lines
end
def self.format_messages(messages: messages, length: 0, align: :ljust)
max_length = messages.map(&:length).max
length = max_length if length < max_length
formatted_messages = messages.map { |message| "│ #{message.send(align, *[length, ' '])} │" }
lines = [
"┌#{'─' * (length + 2)}┐",
formatted_messages,
"└#{'─' * (length + 2)}┘"
]
lines.flatten
end
def self.format_card(card)
name_to_symbol = { spades: '♠', diamonds: '♦', hearts: '♥', clubs: '♣' }
suit = name_to_symbol[card.suit]
literal = card.literal
card_is_ten = literal == '10'
top_literal = card_is_ten ? literal : "#{literal} "
bottom_literal = card_is_ten ? literal : " #{literal}"
[
'┌───────┐',
"│ #{top_literal} │",
'│ │',
"│ #{suit} │",
'│ │',
"│ #{bottom_literal} │",
'└───────┘'
]
end
def self.clear_screen
system('clear')
end
end
end
| 32.489655 | 98 | 0.560603 |
e9276a60e201a9b85e09bc0af339a823a5e74237 | 2,008 | class WorkItemStatesController < ApplicationController
respond_to :html, :json
before_action :authenticate_user!
before_action :set_item_and_state, only: [:show, :update]
before_action :init_from_params, only: :create
after_action :verify_authorized
def create
authorize @state_item
respond_to do |format|
if @state_item.save
format.json { render json: @state_item, status: :created }
else
format.json { render json: @state_item.errors, status: :unprocessable_entity }
end
end
end
def update
@state_item.update(params_for_update) if @state_item
authorize @state_item
respond_to do |format|
if @state_item.save
format.json { render json: @state_item, status: :ok }
else
format.json { render json: @state_item.errors, status: :unprocessable_entity }
end
end
end
def show
if @state_item.nil?
authorize current_user, :state_show?
respond_to do |format|
format.json { render body: nil, status: :not_found and return }
format.html { redirect_to root_url, alert: 'That Work Item State could not be found.' }
end
else
authorize @state_item
respond_to do |format|
format.json { render json: @state_item.serializable_hash }
end
end
end
private
def init_from_params
@state_item = WorkItemState.new(work_item_state_params)
end
def work_item_state_params
if request.method == 'GET'
params.require(:id)
else
params[:work_item_state] &&= params.require(:work_item_state).permit(:work_item_id, :action, :state)
end
end
def params_for_update
params.require(:work_item_state).permit(:action, :state)
end
def set_item_and_state
if params[:id]
begin
@state_item = WorkItemState.readable(current_user).find(params[:id])
@work_item = @state_item.work_item
rescue
# Don't throw RecordNotFound. Just return 404 above.
end
end
end
end
| 26.773333 | 106 | 0.679283 |
e95be460b2e33f758ba500b270398d51518bcc4f | 10,132 | # frozen_string_literal: true
require_relative '../test_helper'
# rubocop:disable Metrics/ClassLength
class GenericSortFilterTest < ActiveSupport::TestCase
subject { GenericSortFilter }
let(:query) { Offer.where('1 = 1') }
let(:invalid_query) { OpenStruct.new }
describe '#snake_case_contents' do
it 'should transform kebab-case contents to snake_case' do
params = {
sort_field: 'foo-bar', sort_model: %w[offer-translation baz-fuz],
sort_direction: 'ASC',
filters: { 'offer-translation.foo-bar' => 'dont-touch' }
}
result = subject.send(:snake_case_contents, params)
result.must_equal(
sort_field: 'foo_bar', sort_model: %w[offer_translation baz_fuz],
sort_direction: 'ASC',
filters: { 'offer_translation.foo_bar' => 'dont-touch' }
)
end
end
describe '#transform_by_searching' do
it 'does nothing without a param' do
invalid_query.expects(:search_pg).never
result = subject.send(:transform_by_searching, invalid_query, nil)
result.must_equal invalid_query
end
it 'does nothing with an empty param' do
invalid_query.expects(:search_pg).never
result = subject.send(:transform_by_searching, invalid_query, '')
result.must_equal invalid_query
end
it 'searches with a filled param for offer' do
query.expects(:search_pg).with('foo').once
subject.send(:transform_by_searching, query, 'foo')
end
# it 'searches with a filled param for orga' do
# orga_query = Organization.where('1 = 1')
# orga_query.expects(:with_pg_search_rank).once
# subject.send(:transform_by_searching, orga_query, 'orga')
# end
end
describe '#transform_by_joining' do
it 'eager_loads with a plain sort_model' do
params = { sort_model: 'contact_people' }
query.expects(:eager_load).with('contact_people')
subject.send(:transform_by_joining, query, params)
end
it 'eager_loads with a nested sort_model' do
params = { sort_model: 'contact_people.foo_bars' }
query.expects(:eager_load).with('contact_people' => 'foo_bars')
subject.send(:transform_by_joining, query, params)
end
it 'eager_loads with a filter' do
params =
{ filters: { 'solution_category.foo' => 'a',
'logic_version.bar' => 'b' } }
query.expects(:eager_load).with('solution_category').returns(query)
query.expects(:eager_load).with('logic_version').returns(query)
result = subject.send(:transform_by_joining, query, params)
result.must_equal query
end
it 'wont eager_load without a sort_model or filter' do
invalid_query.expects(:eager_load).never
result = subject.send(:transform_by_joining, invalid_query, {})
result.must_equal invalid_query
end
it 'wont eager_load with a filter that references itself' do
params = { filters: ['offer.baz'] }
query.expects(:eager_load).never
subject.send(:transform_by_joining, query, params)
end
it 'wont eager_load with a filter that uses no submodel' do
params = { filters: ['fuz'] }
query.expects(:eager_load).never
subject.send(:transform_by_joining, query, params)
end
end
describe '#transform_by_ordering' do
it 'will order with a sort_field but without sort_model (query model)' do
params = { sort_field: 'foo' }
query.expects(:order).with('offers.foo DESC')
subject.send(:transform_by_ordering, query, params)
end
it 'will order respecting sort_field, sort_model, and sort_direction' do
params =
{ sort_field: 'bar', sort_model: 'solution_category',
sort_direction: 'ASC' }
query.expects(:order).with('solution_categories.bar ASC')
subject.send(:transform_by_ordering, query, params)
end
end
describe '#model_for_filter' do
it 'should classifiy and constantize for self-referring query' do
subject.send(:model_for_filter, query, 'offer.name').must_equal Offer
end
end
describe '#sort_range' do
it 'should correctly sort date values' do
values = [DateTime.current, DateTime.current - 1.day]
subject.send(:sort_range, values).must_equal values.sort
end
it 'should correctly sort non date values via to_i' do
values = [12, 8]
subject.send(:sort_range, values).must_equal [8, 12]
end
end
describe '#transform_by_filtering' do
it 'wont transform without filters' do
params = { filters: nil }
invalid_query.expects(:where).never
result = subject.send(:transform_by_filtering, invalid_query, params)
result.must_equal invalid_query
end
it 'wont transform with an empty filter set' do
params = { filters: {} }
invalid_query.expects(:where).never
result = subject.send(:transform_by_filtering, invalid_query, params)
result.must_equal invalid_query
end
it 'wont transform with an empty filter value' do
params = { filters: { foo: '' } }
invalid_query.expects(:where).never
result = subject.send(:transform_by_filtering, invalid_query, params)
result.must_equal invalid_query
end
it 'filters for an owned field' do
params = { filters: { 'foo' => 'bar' }, controller: 'api/controller' }
query.expects(:where).with("controller.foo = 'bar'")
subject.send(:transform_by_filtering, query, params)
end
it 'filters for an array of owned field with default OR-joining' do
params = { filters: { 'foo' => %w[bar fuz] } }
query.expects(:where).with("foo = 'bar' OR foo = 'fuz'")
subject.send(:transform_by_filtering, query, params)
end
it 'filters for an array of owned field with !=-operator and AND-joining' do
params = { filters: { 'x' => %w[bar fuz] }, operators: { 'x' => '!=' } }
query.expects(:where)
.with("x != 'bar' OR x IS NULL AND x != 'fuz' OR x IS NULL")
subject.send(:transform_by_filtering, query, params)
end
it 'filters with a mismatching association/table name' do
params = { filters: { 'language_filters.foobar' => 'bazfuz' } }
query.expects(:where).with("filters.foobar = 'bazfuz'")
subject.send(:transform_by_filtering, query, params)
end
it 'filters with a 2-level deep association' do
params = { filters: { 'section.cities.foobar' => 'bazfuz' } }
query.expects(:where).with("cities.foobar = 'bazfuz'")
subject.send(:transform_by_filtering, query, params)
end
it 'filters with referring_to_own_table' do
params = { filters: { 'offers.foobar' => 'bazfuz' } }
query.expects(:where).with("offers.foobar = 'bazfuz'")
subject.send(:transform_by_filtering, query, params)
end
it 'filters with a nullable value' do
params = { filters: { 'solution_category.baz' => 'nil' } }
query.expects(:where).with('solution_categories.baz IS NULL')
subject.send(:transform_by_filtering, query, params)
end
it 'filters with a nullable value and NOT operator value' do
params = { filters: { 'fuz' => 'NULL' }, operators: { 'fuz' => '!=' } }
query.expects(:where).with('fuz IS NOT NULL')
subject.send(:transform_by_filtering, query, params)
end
it 'includes NULL values for a "!=" string search' do
params =
{ filters: { 'title' => 'smth' }, operators: { 'title' => '!=' } }
query.expects(:where).with("title != 'smth' OR title IS NULL")
subject.send(:transform_by_filtering, query, params)
end
it 'performs case insensitive search with "ILIKE" operator' do
params =
{ filters: { 'title' => 'Smth' }, operators: { 'title' => 'ILIKE' } }
query.expects(:where).with("CAST(title AS TEXT) ILIKE '%Smth%'")
subject.send(:transform_by_filtering, query, params)
end
it 'parses times and converts them correctly' do
query = Opening.where('1 = 1')
params = { filters: { 'open' => '13:00' } }
query.expects(:where).with("open = '13:00'")
subject.send(:transform_by_filtering, query, params)
end
it 'parses datetimes and converts them correctly' do
value = '15.09.2014, 13:00'
params = { filters: { 'created_at' => value } }
query.expects(:where)
.with("created_at = '#{Time.zone.parse(value).to_datetime}'")
subject.send(:transform_by_filtering, query, params)
end
it 'filters and sorts a range when range consists of dates' do
params = {
filters: { 'foo' => { 'first' => '2017-08-15',
'second' => '2017-08-09' } },
operators: { 'foo' => '...' }
}
query.expects(:where).with("foo BETWEEN '2017-08-09' AND '2017-08-15'")
subject.send(:transform_by_filtering, query, params)
end
it 'filters and sorts a range when range consists of numbers' do
params = {
filters: { 'foo' => { 'first' => '5', 'second' => '1' } },
operators: { 'foo' => '...' }
}
query.expects(:where).with("foo BETWEEN '1' AND '5'")
subject.send(:transform_by_filtering, query, params)
end
it 'filters for a single value when no second value is given for range' do
params = { filters: { 'foo' => '5' }, operators: { 'foo' => '...' } }
query.expects(:where).with("foo = '5'")
subject.send(:transform_by_filtering, query, params)
end
it 'filters for a single value when empty second'\
' value is given for range' do
params = { filters: { 'foo' => ['5', ''] },
operators: { 'foo' => '...' } }
query.expects(:where).with("foo = '5'")
subject.send(:transform_by_filtering, query, params)
end
it 'filters with interconnecting OR operator' do
params = {
filters: { 'foo' => '1', 'fuz' => 'nil' },
operators: { 'fuz' => '=', 'interconnect' => 'OR' }
}
query.expects(:where).with("foo = '1'").returns query
query.expects(:or).with('fuz IS NULL')
subject.send(:transform_by_filtering, query, params)
end
end
end
# rubocop:enable Metrics/ClassLength
| 37.25 | 80 | 0.639262 |
26ecb26970d943bd42012d43b875823659409f28 | 2,154 | # -*- encoding: utf-8 -*-
# stub: websocket-driver 0.6.5 ruby lib
# stub: ext/websocket-driver/extconf.rb
Gem::Specification.new do |s|
s.name = "websocket-driver".freeze
s.version = "0.6.5"
s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
s.require_paths = ["lib".freeze]
s.authors = ["James Coglan".freeze]
s.date = "2017-01-22"
s.email = "[email protected]".freeze
s.extensions = ["ext/websocket-driver/extconf.rb".freeze]
s.extra_rdoc_files = ["README.md".freeze]
s.files = ["README.md".freeze, "ext/websocket-driver/extconf.rb".freeze]
s.homepage = "http://github.com/faye/websocket-driver-ruby".freeze
s.licenses = ["MIT".freeze]
s.rdoc_options = ["--main".freeze, "README.md".freeze, "--markup".freeze, "markdown".freeze]
s.rubygems_version = "2.6.13".freeze
s.summary = "WebSocket protocol handler with pluggable I/O".freeze
s.installed_by_version = "2.6.13" if s.respond_to? :installed_by_version
if s.respond_to? :specification_version then
s.specification_version = 4
if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
s.add_runtime_dependency(%q<websocket-extensions>.freeze, [">= 0.1.0"])
s.add_development_dependency(%q<eventmachine>.freeze, [">= 0"])
s.add_development_dependency(%q<permessage_deflate>.freeze, [">= 0"])
s.add_development_dependency(%q<rake-compiler>.freeze, ["~> 0.8.0"])
s.add_development_dependency(%q<rspec>.freeze, [">= 0"])
else
s.add_dependency(%q<websocket-extensions>.freeze, [">= 0.1.0"])
s.add_dependency(%q<eventmachine>.freeze, [">= 0"])
s.add_dependency(%q<permessage_deflate>.freeze, [">= 0"])
s.add_dependency(%q<rake-compiler>.freeze, ["~> 0.8.0"])
s.add_dependency(%q<rspec>.freeze, [">= 0"])
end
else
s.add_dependency(%q<websocket-extensions>.freeze, [">= 0.1.0"])
s.add_dependency(%q<eventmachine>.freeze, [">= 0"])
s.add_dependency(%q<permessage_deflate>.freeze, [">= 0"])
s.add_dependency(%q<rake-compiler>.freeze, ["~> 0.8.0"])
s.add_dependency(%q<rspec>.freeze, [">= 0"])
end
end
| 43.959184 | 112 | 0.668059 |
5d887dd8dd81c473630c115d3fbb67358dd3dc42 | 8,323 | =begin
PureCloud Platform API
With the PureCloud Platform API, you can control all aspects of your PureCloud environment. With the APIs you can access the system configuration, manage conversations and more.
OpenAPI spec version: v2
Contact: [email protected]
Generated by: https://github.com/swagger-api/swagger-codegen.git
License: UNLICENSED
https://help.mypurecloud.com/articles/terms-and-conditions/
Terms of Service: https://help.mypurecloud.com/articles/terms-and-conditions/
=end
require 'date'
module PureCloud
class OrphanRecordingListing
attr_accessor :entities
attr_accessor :page_size
attr_accessor :page_number
attr_accessor :total
attr_accessor :first_uri
attr_accessor :self_uri
attr_accessor :next_uri
attr_accessor :last_uri
attr_accessor :previous_uri
attr_accessor :page_count
# Attribute mapping from ruby-style variable name to JSON key.
def self.attribute_map
{
:'entities' => :'entities',
:'page_size' => :'pageSize',
:'page_number' => :'pageNumber',
:'total' => :'total',
:'first_uri' => :'firstUri',
:'self_uri' => :'selfUri',
:'next_uri' => :'nextUri',
:'last_uri' => :'lastUri',
:'previous_uri' => :'previousUri',
:'page_count' => :'pageCount'
}
end
# Attribute type mapping.
def self.swagger_types
{
:'entities' => :'Array<OrphanRecording>',
:'page_size' => :'Integer',
:'page_number' => :'Integer',
:'total' => :'Integer',
:'first_uri' => :'String',
:'self_uri' => :'String',
:'next_uri' => :'String',
:'last_uri' => :'String',
:'previous_uri' => :'String',
:'page_count' => :'Integer'
}
end
# Initializes the object
# @param [Hash] attributes Model attributes in the form of hash
def initialize(attributes = {})
return unless attributes.is_a?(Hash)
# convert string to symbol for hash key
attributes = attributes.each_with_object({}){|(k,v), h| h[k.to_sym] = v}
if attributes.has_key?(:'entities')
if (value = attributes[:'entities']).is_a?(Array)
self.entities = value
end
end
if attributes.has_key?(:'pageSize')
self.page_size = attributes[:'pageSize']
end
if attributes.has_key?(:'pageNumber')
self.page_number = attributes[:'pageNumber']
end
if attributes.has_key?(:'total')
self.total = attributes[:'total']
end
if attributes.has_key?(:'firstUri')
self.first_uri = attributes[:'firstUri']
end
if attributes.has_key?(:'selfUri')
self.self_uri = attributes[:'selfUri']
end
if attributes.has_key?(:'nextUri')
self.next_uri = attributes[:'nextUri']
end
if attributes.has_key?(:'lastUri')
self.last_uri = attributes[:'lastUri']
end
if attributes.has_key?(:'previousUri')
self.previous_uri = attributes[:'previousUri']
end
if attributes.has_key?(:'pageCount')
self.page_count = attributes[:'pageCount']
end
end
# Show invalid properties with the reasons. Usually used together with valid?
# @return Array for valid properies with the reasons
def list_invalid_properties
invalid_properties = Array.new
return invalid_properties
end
# Check to see if the all the properties in the model are valid
# @return true if the model is valid
def valid?
end
# Checks equality by comparing each attribute.
# @param [Object] Object to be compared
def ==(o)
return true if self.equal?(o)
self.class == o.class &&
entities == o.entities &&
page_size == o.page_size &&
page_number == o.page_number &&
total == o.total &&
first_uri == o.first_uri &&
self_uri == o.self_uri &&
next_uri == o.next_uri &&
last_uri == o.last_uri &&
previous_uri == o.previous_uri &&
page_count == o.page_count
end
# @see the `==` method
# @param [Object] Object to be compared
def eql?(o)
self == o
end
# Calculates hash code according to all attributes.
# @return [Fixnum] Hash code
def hash
[entities, page_size, page_number, total, first_uri, self_uri, next_uri, last_uri, previous_uri, page_count].hash
end
# build the object from hash
def build_from_hash(attributes)
return nil unless attributes.is_a?(Hash)
self.class.swagger_types.each_pair do |key, type|
if type =~ /^Array<(.*)>/i
if attributes[self.class.attribute_map[key]].is_a?(Array)
self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| _deserialize($1, v) } )
else
#TODO show warning in debug mode
end
elsif !attributes[self.class.attribute_map[key]].nil?
self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
else
# data not found in attributes(hash), not an issue as the data can be optional
end
end
self
end
def _deserialize(type, value)
case type.to_sym
when :DateTime
DateTime.parse(value)
when :Date
Date.parse(value)
when :String
value.to_s
when :Integer
value.to_i
when :Float
value.to_f
when :BOOLEAN
if value.to_s =~ /^(true|t|yes|y|1)$/i
true
else
false
end
when :Object
# generic object (usually a Hash), return directly
value
when /\AArray<(?<inner_type>.+)>\z/
inner_type = Regexp.last_match[:inner_type]
value.map { |v| _deserialize(inner_type, v) }
when /\AHash<(?<k_type>.+), (?<v_type>.+)>\z/
k_type = Regexp.last_match[:k_type]
v_type = Regexp.last_match[:v_type]
{}.tap do |hash|
value.each do |k, v|
hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
end
end
else # model
_model = Object.const_get("PureCloud").const_get(type).new
_model.build_from_hash(value)
end
end
def to_s
to_hash.to_s
end
# to_body is an alias to to_body (backward compatibility))
def to_body
to_hash
end
# return the object in the form of hash
def to_hash
hash = {}
self.class.attribute_map.each_pair do |attr, param|
value = self.send(attr)
next if value.nil?
hash[param] = _to_hash(value)
end
hash
end
# Method to output non-array value in the form of hash
# For object, use to_hash. Otherwise, just return the value
def _to_hash(value)
if value.is_a?(Array)
value.compact.map{ |v| _to_hash(v) }
elsif value.is_a?(Hash)
{}.tap do |hash|
value.each { |k, v| hash[k] = _to_hash(v) }
end
elsif value.respond_to? :to_hash
value.to_hash
else
value
end
end
end
end
| 19.400932 | 177 | 0.515199 |
08857831b4b8fa7a61d11d19bd1bc1b38ab3323d | 2,936 | module Jekyll
module Paginate
class Pagination < Generator
# This generator is safe from arbitrary code execution.
safe true
# This generator should be passive with regard to its execution
priority :lowest
# Generate paginated pages if necessary.
#
# site - The Site.
#
# Returns nothing.
def generate(site)
if Pager.pagination_enabled?(site)
if template = self.class.template_page(site)
paginate(site, template)
else
Jekyll.logger.warn "Pagination:", "Pagination is enabled, but I couldn't find " +
"an index.html page to use as the pagination template. Skipping pagination."
end
end
end
# Paginates the blog's posts. Renders the index.html file into paginated
# directories, e.g.: page2/index.html, page3/index.html, etc and adds more
# site-wide data.
#
# site - The Site.
# page - The index.html Page that requires pagination.
#
# {"paginator" => { "page" => <Number>,
# "per_page" => <Number>,
# "posts" => [<Post>],
# "total_posts" => <Number>,
# "total_pages" => <Number>,
# "previous_page" => <Number>,
# "next_page" => <Number> }}
def paginate(site, page)
all_posts = site.site_payload['site']['posts'].reject { |post| post['hidden'] }
#all_posts = all_posts.select do |elem|
# !elem.data['tags'].include? 'foo'
#end
pages = Pager.calculate_pages(all_posts, site.config['paginate'].to_i)
(1..pages).each do |num_page|
pager = Pager.new(site, num_page, all_posts, pages)
if num_page > 1
newpage = Page.new(site, site.source, page.dir, page.name)
newpage.pager = pager
newpage.dir = Pager.paginate_path(site, num_page)
site.pages << newpage
else
page.pager = pager
end
end
end
# Static: Fetch the URL of the template page. Used to determine the
# path to the first pager in the series.
#
# site - the Jekyll::Site object
#
# Returns the url of the template page
def self.first_page_url(site)
if page = Pagination.template_page(site)
page.url
else
nil
end
end
# Public: Find the Jekyll::Page which will act as the pager template
#
# site - the Jekyll::Site object
#
# Returns the Jekyll::Page which will act as the pager template
def self.template_page(site)
site.pages.select do |page|
Pager.pagination_candidate?(site.config, page)
end.sort do |one, two|
two.path.size <=> one.path.size
end.first
end
end
end
end
| 32.622222 | 93 | 0.553815 |
0136deaccac61ac6d26c0da85410f2c28529d636 | 675 | require 'spec_helper'
describe "FriendlyForwardings", :type => :request do
describe "GET /friendly_forwardings", :type => :request do
it "should forward to the requested page after signin" do
user = FactoryBot.create(:user)
visit edit_user_path(user)
fill_in :email, :with => user.email
fill_in :password, :with => user.password
click_button
expect(response).to render_template('users/edit')
visit signout_path
visit signin_path
fill_in :email, :with => user.email
fill_in :password, :with => user.password
click_button
expect(response).to render_template('users/show')
end
end
end
| 29.347826 | 61 | 0.671111 |
ab13830922f5383e53bd67820bc738a6c15e97ba | 2,504 | require 'socket'
require 'syslog_protocol'
module RemoteSyslogSender
class Sender
# To suppress initialize warning
class Packet < SyslogProtocol::Packet
def initialize(*)
super
@time = nil
end
end
attr_reader :socket
attr_accessor :packet
def initialize(remote_hostname, remote_port, options = {})
@remote_hostname = remote_hostname
@remote_port = remote_port
@whinyerrors = options[:whinyerrors]
@packet_size = options[:packet_size] || 1024
@packet = Packet.new
local_hostname = options[:hostname] || options[:local_hostname] || (Socket.gethostname rescue `hostname`.chomp)
local_hostname = 'localhost' if local_hostname.nil? || local_hostname.empty?
@packet.hostname = local_hostname
@packet.facility = options[:facility] || 'user'
@packet.severity = options[:severity] || 'notice'
@packet.tag = options[:tag] || options[:program] || "#{File.basename($0)}[#{$$}]"
@packet.rfc = options[:rfc] || :rfc5424
@socket = nil
end
def transmit(message, packet_options = nil)
message.split(/\r?\n/).each do |line|
begin
next if line =~ /^\s*$/
packet = @packet.dup
if packet_options
packet.tag = packet_options[:program] if packet_options[:program]
packet.hostname = packet_options[:local_hostname] if packet_options[:local_hostname]
packet.rfc = packet_options[:rfc] if packet_options[:rfc]
if packet.rfc == :rfc5424
%i(hostname facility severity appname msgid procid).each do |key|
packet.send("#{key}=", packet_options[key]) if packet_options[key]
end
else
%i(hostname facility severity tag).each do |key|
packet.send("#{key}=", packet_options[key]) if packet_options[key]
end
end
end
packet.content = line
send_msg(packet.assemble(@packet_size))
rescue
if @whinyerrors
raise
else
$stderr.puts "#{self.class} error: #{$!.class}: #{$!}\nOriginal message: #{line}"
end
end
end
end
# Make this act a little bit like an `IO` object
alias_method :write, :transmit
def close
@socket.close
end
private
def send_msg(payload)
raise NotImplementedError, "please override"
end
end
end
| 30.536585 | 119 | 0.59385 |
61b422f72e67279afff9cd8bc49e35cea7d07312 | 1,715 | class AddInfoAboutLastTransferRequestOnBalance < ActiveRecord::Migration
def up
execute %Q{
CREATE OR REPLACE VIEW "1".balances as
select
id as user_id,
balance.amount as amount,
last_transfer.amount as last_transfer_amount,
last_transfer.created_at as last_transfer_created_at,
last_transfer.in_period_yet
from public.users u
left join lateral (
SELECT sum(bt.amount) AS amount
FROM balance_transactions bt
WHERE bt.user_id = u.id
) as balance on true
left join lateral (
select
(bt.amount * -1) as amount,
bt.created_at,
(to_char(bt.created_at, 'MM/YYY') = to_char(now(), 'MM/YYY')) as in_period_yet
from balance_transactions bt
where bt.user_id = u.id
and bt.event_name in ('balance_transfer_request', 'balance_transfer_project')
and not exists (
select true
from balance_transactions bt2
where bt2.user_id = u.id
and bt2.created_at > bt.created_at
and bt2.event_name = 'balance_transfer_error'
)
order by bt.created_at desc
limit 1
) as last_transfer on true
where is_owner_or_admin(u.id);
}
end
def down
execute %Q{
drop view "1".balances;
CREATE OR REPLACE VIEW "1"."balances" AS
SELECT bt.user_id,
sum(bt.amount) AS amount
FROM balance_transactions bt
WHERE is_owner_or_admin(bt.user_id)
GROUP BY bt.user_id;
}
end
end
| 33.627451 | 97 | 0.568513 |
182a3c4b56ecde4f58f10258caeea922035153f0 | 944 | # == Schema Information
# Schema version: 16
#
# Table name: items
#
# id :integer not null, primary key
# type :string(255) not null
# title :string(255) not null
# project_id :integer
# role_id :integer not null
# person_id :integer not null
# status_id :integer not null
# code_id_priority :integer not null
# project_id_escalation :integer
# description :text
# due_on :date
# lft :integer
# rgt :integer
# updated_at :datetime not null
# person_id_updated_by :integer not null
# version :integer
# res_idx_fti :string
#
class TestCondition < Item
has_one :detail, :class_name => 'TestConditionDetail'
end
| 32.551724 | 61 | 0.48411 |
1d7399f58eff5e168c65bfe41d0a5c12c93b965a | 338 | # frozen_string_literal: true
module Fourier
module Services
module Test
module Tuist
class Unit < Base
def call
Utilities::System.system(
"swift", "test",
"--package-path", Constants::ROOT_DIRECTORY
)
end
end
end
end
end
end
| 18.777778 | 57 | 0.517751 |
11328edbda46ca15905a685c480a786d266ba551 | 3,843 | # == Schema Information
#
# Table name: papers
#
# id :integer not null, primary key
# uid :text not null
# submitter :text
# title :text not null
# abstract :text not null
# author_comments :text
# msc_class :text
# report_no :text
# journal_ref :text
# doi :text
# proxy :text
# license :text
# submit_date :datetime not null
# update_date :datetime not null
# abs_url :text not null
# pdf_url :text not null
# created_at :datetime
# updated_at :datetime
# scites_count :integer default(0), not null
# comments_count :integer default(0), not null
# pubdate :datetime
# author_str :text not null
# versions_count :integer default(1), not null
#
require 'spec_helper'
describe Paper do
let(:paper) { FactoryGirl.create(:paper) }
subject { paper }
it { is_expected.to respond_to(:title) }
it { is_expected.to respond_to(:authors) }
it { is_expected.to respond_to(:abstract) }
it { is_expected.to respond_to(:uid) }
it { is_expected.to respond_to(:abs_url) }
it { is_expected.to respond_to(:pdf_url) }
it { is_expected.to respond_to(:submit_date) }
it { is_expected.to respond_to(:update_date) }
it { is_expected.to respond_to(:scites) }
it { is_expected.to respond_to(:sciters) }
it { is_expected.to respond_to(:comments) }
it { is_expected.to respond_to(:categories) }
it { is_expected.to validate_uniqueness_of(:uid).case_insensitive }
it { is_expected.to be_valid }
describe "#to_bibtex" do
let(:paper) do
paper = FactoryGirl.create(:paper_with_versions,
author_str: "Susanta K. Khan and Madhumangal Pal",
title: "Interval-Valued Intuitionistic Fuzzy Matrices",
pubdate: "2014-05-12 01:00:00 UTC",
uid: "1404.6949",
journal_ref: "Notes on Intuitionistic Fuzzy Sets, 11(1) (2005)16-27"
)
FactoryGirl.create(:author, fullname: "Susanta K. Khan", paper_uid: paper.uid)
FactoryGirl.create(:author, fullname: "Madhumangal Pal", paper_uid: paper.uid)
paper
end
it "generates bibtex correctly" do
expect(paper.to_bibtex).to eq %Q{@misc{1404.6949,
author = {Susanta K.~Khan and Madhumangal Pal},
title = {{I}nterval-{V}alued {I}ntuitionistic {F}uzzy {M}atrices},
year = {2014},
eprint = {1404.6949},
howpublished = {Notes on Intuitionistic Fuzzy Sets, 11(1) (2005)16-27},
note = {arXiv:1404.6949v3}
}}
end
end
describe "sciting" do
let (:user) { FactoryGirl.create(:user) }
before { user.scite!(paper) }
it "scites the paper" do
expect(paper.sciters.pluck(:id)).to include(user.id)
end
end
describe "authors" do
let (:author1) { FactoryGirl.create(:author, paper: paper, position: 0) }
let (:author2) { FactoryGirl.create(:author, paper: paper, position: 1) }
it "should have the authors in the right order" do
expect(paper.reload.authors).to eq [author1, author2]
end
end
describe "comments" do
let (:user) { FactoryGirl.create(:user) }
before { user.save }
let!(:old_comment) do
FactoryGirl.create(:comment,
user: user, paper: paper, created_at: 1.day.ago)
end
let!(:new_comment) do
FactoryGirl.create(:comment,
user: user, paper: paper, created_at: 1.minute.ago)
end
let!(:med_comment) do
FactoryGirl.create(:comment,
user: user, paper: paper, created_at: 1.hour.ago)
end
it "has the right comments in the right order" do
expect(paper.comments).to eq [old_comment, med_comment, new_comment]
end
end
end
| 31.760331 | 84 | 0.617486 |
388bf2ca5a653ae3af4a729a6e3b4372dbab5367 | 412 | # current_CriticalBugs = 14
# moreInfo = "Critical status"
# differenceRate = -10
#
# SCHEDULER.every '1s' do
# last_CriticalBugs = current_CriticalBugs
# send_event('CriticalBugs', { current: current_CriticalBugs, last: last_CriticalBugs, moreinfo: moreInfo, difference:differenceRate })
# end
SCHEDULER.every '1s' do
send_event('TotalBugs', { current: 85, last: 70, moreinfo: "Normal status"})
end
| 29.428571 | 137 | 0.735437 |
030d5bb2bd8111fd68b90473484930472c02a989 | 596 | # frozen_string_literal: true
class MakeExpressionsLessGeneric < ActiveRecord::Migration[4.2]
def up
rename_column :expressions, :parent_id, :post_id
rename_column :expressions, :expression_type_id, :expression_index
remove_column :expressions, :parent_type
add_index :expressions, [:post_id, :expression_index, :user_id], unique: true, name: 'unique_by_user'
end
def down
rename_column :expressions, :post_id, :parent_id
rename_column :expressions, :expression_index, :expression_type_id
add_column :expressions, :parent_type, :string, null: true
end
end
| 31.368421 | 105 | 0.763423 |
e27c314e51a3fa4e4491ef40ad6fb740c5edeb03 | 195 | class InvoicePolicy < ApplicationPolicy
def index?
user.is_admin?
end
def download?
user.is_admin? or (record.user_id == user.id)
end
def create?
user.is_admin?
end
end
| 13.928571 | 49 | 0.676923 |
91aa59aada1e4a6718d9ac66a38ed8f50844180e | 21,309 | ##
# This code was generated by
# \ / _ _ _| _ _
# | (_)\/(_)(_|\/| |(/_ v1.0.0
# / /
#
# frozen_string_literal: true
module Twilio
module REST
class Preview < Domain
class HostedNumbers < Version
##
# PLEASE NOTE that this class contains preview products that are subject to change. Use them with caution. If you currently do not have developer preview access, please contact [email protected].
class AuthorizationDocumentList < ListResource
##
# Initialize the AuthorizationDocumentList
# @param [Version] version Version that contains the resource
# @return [AuthorizationDocumentList] AuthorizationDocumentList
def initialize(version)
super(version)
# Path Solution
@solution = {}
@uri = "/AuthorizationDocuments"
end
##
# Lists AuthorizationDocumentInstance records from the API as a list.
# Unlike stream(), this operation is eager and will load `limit` records into
# memory before returning.
# @param [String] email Email that this AuthorizationDocument will be sent to for
# signing.
# @param [authorization_document.Status] status Status of an instance resource. It
# can hold one of the values: 1. opened 2. signing, 3. signed LOA, 4. canceled, 5.
# failed. See the section entitled [Status
# Values](https://www.twilio.com/docs/api/phone-numbers/hosted-number-authorization-documents#status-values) for more information on each of these statuses.
# @param [Integer] limit Upper limit for the number of records to return. stream()
# guarantees to never return more than limit. Default is no limit
# @param [Integer] page_size Number of records to fetch per request, when
# not set will use the default value of 50 records. If no page_size is defined
# but a limit is defined, stream() will attempt to read the limit with the most
# efficient page size, i.e. min(limit, 1000)
# @return [Array] Array of up to limit results
def list(email: :unset, status: :unset, limit: nil, page_size: nil)
self.stream(email: email, status: status, limit: limit, page_size: page_size).entries
end
##
# Streams AuthorizationDocumentInstance records from the API as an Enumerable.
# This operation lazily loads records as efficiently as possible until the limit
# is reached.
# @param [String] email Email that this AuthorizationDocument will be sent to for
# signing.
# @param [authorization_document.Status] status Status of an instance resource. It
# can hold one of the values: 1. opened 2. signing, 3. signed LOA, 4. canceled, 5.
# failed. See the section entitled [Status
# Values](https://www.twilio.com/docs/api/phone-numbers/hosted-number-authorization-documents#status-values) for more information on each of these statuses.
# @param [Integer] limit Upper limit for the number of records to return. stream()
# guarantees to never return more than limit. Default is no limit.
# @param [Integer] page_size Number of records to fetch per request, when
# not set will use the default value of 50 records. If no page_size is defined
# but a limit is defined, stream() will attempt to read the limit with the most
# efficient page size, i.e. min(limit, 1000)
# @return [Enumerable] Enumerable that will yield up to limit results
def stream(email: :unset, status: :unset, limit: nil, page_size: nil)
limits = @version.read_limits(limit, page_size)
page = self.page(email: email, status: status, page_size: limits[:page_size], )
@version.stream(page, limit: limits[:limit], page_limit: limits[:page_limit])
end
##
# When passed a block, yields AuthorizationDocumentInstance records from the API.
# This operation lazily loads records as efficiently as possible until the limit
# is reached.
def each
limits = @version.read_limits
page = self.page(page_size: limits[:page_size], )
@version.stream(page,
limit: limits[:limit],
page_limit: limits[:page_limit]).each {|x| yield x}
end
##
# Retrieve a single page of AuthorizationDocumentInstance records from the API.
# Request is executed immediately.
# @param [String] email Email that this AuthorizationDocument will be sent to for
# signing.
# @param [authorization_document.Status] status Status of an instance resource. It
# can hold one of the values: 1. opened 2. signing, 3. signed LOA, 4. canceled, 5.
# failed. See the section entitled [Status
# Values](https://www.twilio.com/docs/api/phone-numbers/hosted-number-authorization-documents#status-values) for more information on each of these statuses.
# @param [String] page_token PageToken provided by the API
# @param [Integer] page_number Page Number, this value is simply for client state
# @param [Integer] page_size Number of records to return, defaults to 50
# @return [Page] Page of AuthorizationDocumentInstance
def page(email: :unset, status: :unset, page_token: :unset, page_number: :unset, page_size: :unset)
params = Twilio::Values.of({
'Email' => email,
'Status' => status,
'PageToken' => page_token,
'Page' => page_number,
'PageSize' => page_size,
})
response = @version.page(
'GET',
@uri,
params
)
AuthorizationDocumentPage.new(@version, response, @solution)
end
##
# Retrieve a single page of AuthorizationDocumentInstance records from the API.
# Request is executed immediately.
# @param [String] target_url API-generated URL for the requested results page
# @return [Page] Page of AuthorizationDocumentInstance
def get_page(target_url)
response = @version.domain.request(
'GET',
target_url
)
AuthorizationDocumentPage.new(@version, response, @solution)
end
##
# Retrieve a single page of AuthorizationDocumentInstance records from the API.
# Request is executed immediately.
# @param [String] hosted_number_order_sids A list of HostedNumberOrder sids that
# this AuthorizationDocument will authorize for hosting phone number capabilities
# on Twilio's platform.
# @param [String] address_sid A 34 character string that uniquely identifies the
# Address resource that is associated with this AuthorizationDocument.
# @param [String] email Email that this AuthorizationDocument will be sent to for
# signing.
# @param [String] contact_title The title of the person authorized to sign the
# Authorization Document for this phone number.
# @param [String] contact_phone_number The contact phone number of the person
# authorized to sign the Authorization Document.
# @param [String] cc_emails Email recipients who will be informed when an
# Authorization Document has been sent and signed.
# @return [AuthorizationDocumentInstance] Newly created AuthorizationDocumentInstance
def create(hosted_number_order_sids: nil, address_sid: nil, email: nil, contact_title: nil, contact_phone_number: nil, cc_emails: :unset)
data = Twilio::Values.of({
'HostedNumberOrderSids' => Twilio.serialize_list(hosted_number_order_sids) { |e| e },
'AddressSid' => address_sid,
'Email' => email,
'ContactTitle' => contact_title,
'ContactPhoneNumber' => contact_phone_number,
'CcEmails' => Twilio.serialize_list(cc_emails) { |e| e },
})
payload = @version.create(
'POST',
@uri,
data: data
)
AuthorizationDocumentInstance.new(@version, payload, )
end
##
# Provide a user friendly representation
def to_s
'#<Twilio.Preview.HostedNumbers.AuthorizationDocumentList>'
end
end
##
# PLEASE NOTE that this class contains preview products that are subject to change. Use them with caution. If you currently do not have developer preview access, please contact [email protected].
class AuthorizationDocumentPage < Page
##
# Initialize the AuthorizationDocumentPage
# @param [Version] version Version that contains the resource
# @param [Response] response Response from the API
# @param [Hash] solution Path solution for the resource
# @return [AuthorizationDocumentPage] AuthorizationDocumentPage
def initialize(version, response, solution)
super(version, response)
# Path Solution
@solution = solution
end
##
# Build an instance of AuthorizationDocumentInstance
# @param [Hash] payload Payload response from the API
# @return [AuthorizationDocumentInstance] AuthorizationDocumentInstance
def get_instance(payload)
AuthorizationDocumentInstance.new(@version, payload, )
end
##
# Provide a user friendly representation
def to_s
'<Twilio.Preview.HostedNumbers.AuthorizationDocumentPage>'
end
end
##
# PLEASE NOTE that this class contains preview products that are subject to change. Use them with caution. If you currently do not have developer preview access, please contact [email protected].
class AuthorizationDocumentContext < InstanceContext
##
# Initialize the AuthorizationDocumentContext
# @param [Version] version Version that contains the resource
# @param [String] sid A 34 character string that uniquely identifies this
# AuthorizationDocument.
# @return [AuthorizationDocumentContext] AuthorizationDocumentContext
def initialize(version, sid)
super(version)
# Path Solution
@solution = {sid: sid, }
@uri = "/AuthorizationDocuments/#{@solution[:sid]}"
# Dependents
@dependent_hosted_number_orders = nil
end
##
# Fetch a AuthorizationDocumentInstance
# @return [AuthorizationDocumentInstance] Fetched AuthorizationDocumentInstance
def fetch
params = Twilio::Values.of({})
payload = @version.fetch(
'GET',
@uri,
params,
)
AuthorizationDocumentInstance.new(@version, payload, sid: @solution[:sid], )
end
##
# Update the AuthorizationDocumentInstance
# @param [String] hosted_number_order_sids A list of HostedNumberOrder sids that
# this AuthorizationDocument will authorize for hosting phone number capabilities
# on Twilio's platform.
# @param [String] address_sid A 34 character string that uniquely identifies the
# Address resource that is associated with this AuthorizationDocument.
# @param [String] email Email that this AuthorizationDocument will be sent to for
# signing.
# @param [String] cc_emails Email recipients who will be informed when an
# Authorization Document has been sent and signed
# @param [authorization_document.Status] status Status of an instance resource. It
# can hold one of the values: 1. opened 2. signing, 3. signed LOA, 4. canceled, 5.
# failed. See the section entitled [Status
# Values](https://www.twilio.com/docs/api/phone-numbers/hosted-number-authorization-documents#status-values) for more information on each of these statuses.
# @param [String] contact_title The title of the person authorized to sign the
# Authorization Document for this phone number.
# @param [String] contact_phone_number The contact phone number of the person
# authorized to sign the Authorization Document.
# @return [AuthorizationDocumentInstance] Updated AuthorizationDocumentInstance
def update(hosted_number_order_sids: :unset, address_sid: :unset, email: :unset, cc_emails: :unset, status: :unset, contact_title: :unset, contact_phone_number: :unset)
data = Twilio::Values.of({
'HostedNumberOrderSids' => Twilio.serialize_list(hosted_number_order_sids) { |e| e },
'AddressSid' => address_sid,
'Email' => email,
'CcEmails' => Twilio.serialize_list(cc_emails) { |e| e },
'Status' => status,
'ContactTitle' => contact_title,
'ContactPhoneNumber' => contact_phone_number,
})
payload = @version.update(
'POST',
@uri,
data: data,
)
AuthorizationDocumentInstance.new(@version, payload, sid: @solution[:sid], )
end
##
# Access the dependent_hosted_number_orders
# @return [DependentHostedNumberOrderList]
# @return [DependentHostedNumberOrderContext]
def dependent_hosted_number_orders
unless @dependent_hosted_number_orders
@dependent_hosted_number_orders = DependentHostedNumberOrderList.new(
@version,
signing_document_sid: @solution[:sid],
)
end
@dependent_hosted_number_orders
end
##
# Provide a user friendly representation
def to_s
context = @solution.map {|k, v| "#{k}: #{v}"}.join(',')
"#<Twilio.Preview.HostedNumbers.AuthorizationDocumentContext #{context}>"
end
##
# Provide a detailed, user friendly representation
def inspect
context = @solution.map {|k, v| "#{k}: #{v}"}.join(',')
"#<Twilio.Preview.HostedNumbers.AuthorizationDocumentContext #{context}>"
end
end
##
# PLEASE NOTE that this class contains preview products that are subject to change. Use them with caution. If you currently do not have developer preview access, please contact [email protected].
class AuthorizationDocumentInstance < InstanceResource
##
# Initialize the AuthorizationDocumentInstance
# @param [Version] version Version that contains the resource
# @param [Hash] payload payload that contains response from Twilio
# @param [String] sid A 34 character string that uniquely identifies this
# AuthorizationDocument.
# @return [AuthorizationDocumentInstance] AuthorizationDocumentInstance
def initialize(version, payload, sid: nil)
super(version)
# Marshaled Properties
@properties = {
'sid' => payload['sid'],
'address_sid' => payload['address_sid'],
'status' => payload['status'],
'email' => payload['email'],
'cc_emails' => payload['cc_emails'],
'date_created' => Twilio.deserialize_iso8601_datetime(payload['date_created']),
'date_updated' => Twilio.deserialize_iso8601_datetime(payload['date_updated']),
'url' => payload['url'],
'links' => payload['links'],
}
# Context
@instance_context = nil
@params = {'sid' => sid || @properties['sid'], }
end
##
# Generate an instance context for the instance, the context is capable of
# performing various actions. All instance actions are proxied to the context
# @return [AuthorizationDocumentContext] AuthorizationDocumentContext for this AuthorizationDocumentInstance
def context
unless @instance_context
@instance_context = AuthorizationDocumentContext.new(@version, @params['sid'], )
end
@instance_context
end
##
# @return [String] AuthorizationDocument sid.
def sid
@properties['sid']
end
##
# @return [String] Address sid.
def address_sid
@properties['address_sid']
end
##
# @return [authorization_document.Status] The Status of this AuthorizationDocument.
def status
@properties['status']
end
##
# @return [String] Email.
def email
@properties['email']
end
##
# @return [String] A list of emails.
def cc_emails
@properties['cc_emails']
end
##
# @return [Time] The date this AuthorizationDocument was created.
def date_created
@properties['date_created']
end
##
# @return [Time] The date this AuthorizationDocument was updated.
def date_updated
@properties['date_updated']
end
##
# @return [String] The url
def url
@properties['url']
end
##
# @return [String] The links
def links
@properties['links']
end
##
# Fetch a AuthorizationDocumentInstance
# @return [AuthorizationDocumentInstance] Fetched AuthorizationDocumentInstance
def fetch
context.fetch
end
##
# Update the AuthorizationDocumentInstance
# @param [String] hosted_number_order_sids A list of HostedNumberOrder sids that
# this AuthorizationDocument will authorize for hosting phone number capabilities
# on Twilio's platform.
# @param [String] address_sid A 34 character string that uniquely identifies the
# Address resource that is associated with this AuthorizationDocument.
# @param [String] email Email that this AuthorizationDocument will be sent to for
# signing.
# @param [String] cc_emails Email recipients who will be informed when an
# Authorization Document has been sent and signed
# @param [authorization_document.Status] status Status of an instance resource. It
# can hold one of the values: 1. opened 2. signing, 3. signed LOA, 4. canceled, 5.
# failed. See the section entitled [Status
# Values](https://www.twilio.com/docs/api/phone-numbers/hosted-number-authorization-documents#status-values) for more information on each of these statuses.
# @param [String] contact_title The title of the person authorized to sign the
# Authorization Document for this phone number.
# @param [String] contact_phone_number The contact phone number of the person
# authorized to sign the Authorization Document.
# @return [AuthorizationDocumentInstance] Updated AuthorizationDocumentInstance
def update(hosted_number_order_sids: :unset, address_sid: :unset, email: :unset, cc_emails: :unset, status: :unset, contact_title: :unset, contact_phone_number: :unset)
context.update(
hosted_number_order_sids: hosted_number_order_sids,
address_sid: address_sid,
email: email,
cc_emails: cc_emails,
status: status,
contact_title: contact_title,
contact_phone_number: contact_phone_number,
)
end
##
# Access the dependent_hosted_number_orders
# @return [dependent_hosted_number_orders] dependent_hosted_number_orders
def dependent_hosted_number_orders
context.dependent_hosted_number_orders
end
##
# Provide a user friendly representation
def to_s
values = @params.map{|k, v| "#{k}: #{v}"}.join(" ")
"<Twilio.Preview.HostedNumbers.AuthorizationDocumentInstance #{values}>"
end
##
# Provide a detailed, user friendly representation
def inspect
values = @properties.map{|k, v| "#{k}: #{v}"}.join(" ")
"<Twilio.Preview.HostedNumbers.AuthorizationDocumentInstance #{values}>"
end
end
end
end
end
end | 45.532051 | 201 | 0.608147 |
878fd7986b68d41d6c12408a0eefc7db9f27f510 | 4,113 | class TestTrack::Visitor
include TestTrack::RequiredOptions
attr_reader :id
def initialize(opts = {})
opts = opts.dup
@id = opts.delete(:id)
@loaded = true if opts[:assignments]
@assignments = opts.delete(:assignments)
unless id
@id = SecureRandom.uuid
@assignments ||= [] # If we're generating a visitor, we don't need to fetch the assignments
end
raise "unknown opts: #{opts.keys.to_sentence}" if opts.present?
end
def vary(split_name, opts = {})
opts = opts.dup
split_name = split_name.to_s
context = require_option!(opts, :context)
raise "unknown opts: #{opts.keys.to_sentence}" if opts.present?
raise ArgumentError, "must provide block to `vary` for #{split_name}" unless block_given?
v = TestTrack::VaryDSL.new(assignment: assignment_for(split_name), context: context, split_registry: split_registry)
yield v
v.send :run
end
def ab(split_name, opts = {}) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
opts = opts.dup
split_name = split_name.to_s
true_variant = opts.delete(:true_variant)
context = require_option!(opts, :context)
raise "unknown opts: #{opts.keys.to_sentence}" if opts.present?
ab_configuration = TestTrack::ABConfiguration.new split_name: split_name, true_variant: true_variant, split_registry: split_registry
vary(split_name, context: context) do |v|
v.when ab_configuration.variants[:true] do
true
end
v.default ab_configuration.variants[:false] do
false
end
end
end
def assignment_registry
@assignment_registry ||= assignments.each_with_object({}) do |assignment, hsh|
hsh[assignment.split_name] = assignment
end
end
def unsynced_assignments
@unsynced_assignments ||= assignment_registry.values.select(&:unsynced?)
end
def assignment_json
assignment_registry.values.each_with_object({}) do |assignment, hsh|
hsh[assignment.split_name] = assignment.variant
end
end
def split_registry
@split_registry ||= TestTrack::Remote::SplitRegistry.to_hash
end
def link_identity!(identity)
opts = identifier_opts(identity)
begin
identifier = TestTrack::Remote::Identifier.create!(opts)
merge!(identifier.visitor)
rescue *TestTrack::SERVER_ERRORS => e
Rails.logger.error "TestTrack failed to link identifier, retrying. #{e}"
# If at first you don't succeed, async it - we may not display 100% consistent UX this time,
# but subsequent requests will be better off
TestTrack::Remote::Identifier.delay.create!(opts)
end
end
def offline?
@tt_offline
end
def id_loaded?
true
end
def loaded?
!offline? && @loaded
end
def id_overridden_by_existing_visitor?
@id_overridden_by_existing_visitor || false
end
private
def identifier_opts(identity)
{
identifier_type: identity.test_track_identifier_type,
visitor_id: id,
value: identity.test_track_identifier_value.to_s
}
end
def assignments
@assignments ||= remote_visitor&.assignments || []
end
def remote_visitor
@remote_visitor ||= _remote_visitor
end
def _remote_visitor
unless tt_offline?
TestTrack::Remote::Visitor.find(id).tap do |_|
@loaded = true
end
end
rescue *TestTrack::SERVER_ERRORS => e
Rails.logger.error "TestTrack failed to load remote visitor. #{e}"
@tt_offline = true
nil
end
def merge!(other)
@id_overridden_by_existing_visitor = id != other.id
@id = other.id
@assignment_registry = assignment_registry.merge(other.assignment_registry)
@unsynced_assignments = nil
end
def tt_offline?
@tt_offline || false
end
def assignment_for(split_name)
fetch_assignment_for(split_name) || generate_assignment_for(split_name)
end
def fetch_assignment_for(split_name)
assignment_registry[split_name] if assignment_registry
end
def generate_assignment_for(split_name)
assignment_registry[split_name] = TestTrack::Assignment.new(visitor: self, split_name: split_name)
end
end
| 27.059211 | 136 | 0.705811 |
1d1b3f648d3a044336dfeb71ebcb086c39d1c110 | 623 | # -*- encoding : utf-8 -*-
difficulty 3
description "A bug was introduced somewhere along the way. You know that running `ruby prog.rb 5` should output 15. You can also run `make test`. What are the first 7 chars of the hash of the commit that introduced the bug."
setup do
init_from_level
repo.init
end
solution do
"18ed2ac" == request("What are the first 7 characters of the hash of the commit that introduced the bug?")[0..6]
end
hint do
puts ["The fastest way to find the bug is with bisect.", "Don't forget to start bisect first, identify a good or bad commit, then run `git bisect run make test`."]
end
| 36.647059 | 227 | 0.727127 |
ed54865411afcae9c6c393d72a7ff84c8193240b | 528 | Headcount.configure do |config|
# config.path = 'db/headcounts.json' # where to write headcount to
config.timestamp = '%'
now = DateTime.now
count User do
a = now - 7.days
b = now - 30.days
c = now - 90.days
count User.where("last_request_at >= ?", a), :as => :active
count User.where("last_request_at < ? AND last_request_at > ?", a, b), :as => :semi_active
count User.where("last_request_at <= ?", c), :as => :inactive
end
end | 33 | 95 | 0.549242 |
187e96be2322babf543f229eaf7170bef2f3610d | 343 | class TreemapGenerator < BaseGenerator
# generate horizontal bar chart
# element - div id or class for chart
# data_url - json file with data
def generate( element, data_url )
add_assets( "#{element[1..-1]}"+'.js', js_code( element, data_url ) )
add_assets( "#{element[1..-1]}"+'.scss', css_code( element ) )
end
end | 31.181818 | 73 | 0.653061 |
2625ccb70342a3725ef387b67aa3a75f66f463a3 | 139 | class Invitation < ActiveRecord::Base
belongs_to(:person) # people can invite other people ...
belongs_to(:team) # ... into teams
end
| 19.857143 | 57 | 0.71223 |
d52e8cfcfe989c00ab277cf1d3fab7b51b740c61 | 3,148 | # This extension Gzips assets and pages when building.
# Gzipped assets and pages can be served directly by Apache or
# Nginx with the proper configuration, and pre-zipping means that we
# can use a more agressive compression level at no CPU cost per request.
#
# Use Nginx's gzip_static directive, or AddEncoding and mod_rewrite in Apache
# to serve your Gzipped files whenever the normal (non-.gz) filename is requested.
#
# Pass the :exts options to customize which file extensions get zipped (defaults
# to .html, .htm, .js and .css.
#
class Middleman::Extensions::Gzip < ::Middleman::Extension
option :exts, %w(.js .css .html .htm), 'File extensions to Gzip when building.'
def initialize(app, options_hash={})
super
require 'zlib'
require 'stringio'
require 'find'
require 'thread'
end
def after_build(builder)
num_threads = 4
paths = ::Middleman::Util.all_files_under(app.build_dir)
total_savings = 0
# Fill a queue with inputs
in_queue = Queue.new
paths.each do |path|
in_queue << path if options.exts.include?(path.extname)
end
num_paths = in_queue.size
# Farm out gzip tasks to threads and put the results in in_queue
out_queue = Queue.new
threads = num_threads.times.map do
Thread.new do
while path = in_queue.pop
out_queue << gzip_file(path.to_s)
end
end
end
# Insert a nil for each thread to stop it
num_threads.times do
in_queue << nil
end
old_locale = I18n.locale
I18n.locale = :en # use the english localizations for printing out file sizes to make sure the localizations exist
num_paths.times do
output_filename, old_size, new_size = out_queue.pop
if output_filename
total_savings += (old_size - new_size)
size_change_word = (old_size - new_size) > 0 ? 'smaller' : 'larger'
builder.say_status :gzip, "#{output_filename} (#{app.number_to_human_size((old_size - new_size).abs)} #{size_change_word})"
end
end
builder.say_status :gzip, "Total gzip savings: #{app.number_to_human_size(total_savings)}", :blue
I18n.locale = old_locale
end
def gzip_file(path)
input_file = File.open(path, 'rb').read
output_filename = path + '.gz'
input_file_time = File.mtime(path)
# Check if the right file's already there
if File.exist?(output_filename) && File.mtime(output_filename) == input_file_time
return [nil, nil, nil]
end
File.open(output_filename, 'wb') do |f|
gz = Zlib::GzipWriter.new(f, Zlib::BEST_COMPRESSION)
gz.mtime = input_file_time.to_i
gz.write input_file
gz.close
end
# Make the file times match, both for Nginx's gzip_static extension
# and so we can ID existing files. Also, so even if the GZ files are
# wiped out by build --clean and recreated, we won't rsync them over
# again because they'll end up with the same mtime.
File.utime(File.atime(output_filename), input_file_time, output_filename)
old_size = File.size(path)
new_size = File.size(output_filename)
[output_filename, old_size, new_size]
end
end
| 32.453608 | 131 | 0.690915 |
d536e1d4d7491a9a29b868b0a526f113a736733f | 260 | class CreateCoffees < ActiveRecord::Migration[6.0]
def change
create_table :coffees do |t|
t.string :name
t.string :notes
t.string :roast
t.belongs_to :roaster, null: false, foreign_key: true
t.timestamps
end
end
end
| 20 | 59 | 0.65 |
21fb98fdde3d8e8e7bc7dd739d4640630482ad1d | 935 | #
# This class was auto-generated from the API references found at
# https://epayments-api.developer-ingenico.com/s2sapi/v1/
#
require 'ingenico/connect/sdk/factory'
require 'ingenico/connect/sdk/domain/payment/capture_payment_request'
Payment = Ingenico::Connect::SDK::Domain::Payment
def example
get_client do |client|
body = Payment::CapturePaymentRequest.new
body.amount = 2980
response = client.merchant('merchantId').payments().capture('paymentId', body)
end
end
def get_client
api_key_id = ENV.fetch('connect.api.apiKeyId', 'someKey')
secret_api_key = ENV.fetch('connect.api.secretApiKey', 'someSecret')
configuration_file_name = File.join(__FILE__, '..', '..', 'example_configuration.yml')
yield client = Ingenico::Connect::SDK::Factory.create_client_from_file(configuration_file_name, api_key_id, secret_api_key)
ensure
# Free networking resources when done
client.close unless client.nil?
end
| 33.392857 | 125 | 0.765775 |
389cc86a35bf6ee4a3f298d378b73fdad3b95bf5 | 137 | FactoryGirl.define do
factory :page do
title 'Test page'
name 'test-page'
path '/test-page'
root_folder_id 1
end
end
| 15.222222 | 21 | 0.656934 |
6ac8bd8282b84fb2f01d282c95948ca326683c69 | 131 | class AddFluidPreferenceToUser < ActiveRecord::Migration
def change
add_column :users, :fluid_preference, :boolean
end
end
| 21.833333 | 56 | 0.78626 |
1165f91707e97ca7a41a1d280738c317f78a96e7 | 19 | test_variable = 42 | 19 | 19 | 0.789474 |
b924affa50f22c5281e4a27ac814aa613a913b6f | 3,817 | require 'spec_helper'
describe Spree::Admin::FavoriteProductsController do
let(:role) { Spree::Role.create!(name: 'user') }
let(:roles) { [role] }
let(:product) { mock_model( Spree::Product) }
let(:proxy_object) { Object.new }
before(:each) do
@user = mock_model(Spree::User, generate_spree_api_key!: false)
allow(@user).to receive(:roles).and_return(proxy_object)
allow(proxy_object).to receive(:includes).and_return([])
allow(@user).to receive(:has_spree_role?).with('admin').and_return(true)
allow(controller).to receive(:spree_user_signed_in?).and_return(true)
allow(controller).to receive(:spree_current_user).and_return(@user)
allow(@user).to receive(:roles).and_return(roles)
allow(roles).to receive(:includes).with(:permissions).and_return(roles)
allow(controller).to receive(:authorize_admin).and_return(true)
allow(controller).to receive(:authorize!).and_return(true)
@favorite_products = double('favorite_products')
allow(@favorite_products).to receive(:includes).and_return(@favorite_products)
allow(@favorite_products).to receive(:order_by_favorite_users_count).and_return(@favorite_products)
allow(@favorite_products).to receive(:joins).and_return(@favorite_products)
@search = double('search', result: @favorite_products)
allow(@favorite_products).to receive(:search).and_return(@search)
allow(@favorite_products).to receive(:page).and_return(@favorite_products)
allow(@favorite_products).to receive(:per).and_return(@favorite_products)
allow(Spree::Product).to receive(:favorite).and_return(@favorite_products)
end
describe "GET index" do
def send_request
get :index, params: { page: 1, q: { s: 'name desc' } }
end
it "returns favorite products" do
expect(Spree::Product).to receive(:favorite)
send_request
end
it "searches favorite products" do
search_params = ActionController::Parameters.new(s: 'name desc')
expect(@favorite_products).to receive(:search).with(search_params)
send_request
end
it "assigns @search" do
send_request
expect(assigns(:search)).to eq(@search)
end
context 'when order favorite products by users count in asc order' do
def send_request
get :index, params: { page: 1, q: { s: 'favorite_users_count asc' } }
end
it "orders favorite products by users count in asc order" do
expect(@favorite_products).to receive(:order_by_favorite_users_count).with(true)
send_request
end
end
context 'when order favorite products by users count in desc order' do
it "orders favorite products by users count in asc order" do
expect(@favorite_products).to receive(:order_by_favorite_users_count).with(false)
send_request
end
end
it "paginates favorite products" do
expect(@favorite_products).to receive(:page).with("1")
send_request
end
it "renders favorite products template" do
send_request
expect(response).to render_template(:index)
end
end
describe "#sort_in_ascending_users_count?" do
context 'when favorite_user_count asc present in params[q][s]' do
def send_request
get :index, params: { page: 1, q: { s: 'favorite_users_count asc' } }
end
it "is true" do
expect(controller.send(:sort_in_ascending_users_count?)).to be true
end
before do
send_request
end
end
context 'when favorite_user_count not present in params' do
def send_request
get :index, params: { page: 1, q: { s: 'name asc' } }
end
it "is false" do
expect(controller.send(:sort_in_ascending_users_count?)).to be false
end
before do
send_request
end
end
end
end
| 33.482456 | 103 | 0.690333 |
ff3b7d2004348cb2dcdeeb21c78f48e20ce6b265 | 333 | module PagSeguro
class Document
include Extensions::Assignment
# Set the type.
attr_accessor :type
# Set the value.
attr_accessor :value
def ==(other)
[type, value] == [other.type, other.value]
end
def cpf?
type == 'CPF'
end
def cnpj?
type == 'CNPJ'
end
end
end
| 13.875 | 48 | 0.570571 |
7a3d5214c7c68506d0b88354dd6c5a8ac7c9ba16 | 5,987 | # frozen_string_literal: true
module Committee
module SchemaValidator
class OpenAPI3
class OperationWrapper
# # @param request_operation [OpenAPIParser::RequestOperation]
def initialize(request_operation)
@request_operation = request_operation
end
def path_params
request_operation.path_params
end
def original_path
request_operation.original_path
end
def coerce_path_parameter(validator_option)
options = build_openapi_parser_path_option(validator_option)
return {} unless options.coerce_value
request_operation.validate_path_params(options)
rescue OpenAPIParser::OpenAPIError => e
raise Committee::InvalidRequest.new(e.message)
end
# @param [Boolean] strict when not content_type or status code definition, raise error
def validate_response_params(status_code, headers, response_data, strict, check_header)
response_body = OpenAPIParser::RequestOperation::ValidatableResponseBody.new(status_code, response_data, headers)
return request_operation.validate_response_body(response_body, response_validate_options(strict, check_header))
rescue OpenAPIParser::OpenAPIError => e
raise Committee::InvalidResponse.new(e.message)
end
def validate_request_params(params, headers, validator_option)
ret, err = case request_operation.http_method
when 'get'
validate_get_request_params(params, headers, validator_option)
when 'post'
validate_post_request_params(params, headers, validator_option)
when 'put'
validate_post_request_params(params, headers, validator_option)
when 'patch'
validate_post_request_params(params, headers, validator_option)
when 'delete'
validate_get_request_params(params, headers, validator_option)
else
raise "Committee OpenAPI3 not support #{request_operation.http_method} method"
end
raise err if err
ret
end
def valid_request_content_type?(content_type)
if (request_body = request_operation.operation_object&.request_body)
!request_body.select_media_type(content_type).nil?
else
# if not exist request body object, all content_type allow.
# because request body object required content field so when it exists there're content type definition.
true
end
end
def request_content_types
request_operation.operation_object&.request_body&.content&.keys || []
end
private
attr_reader :request_operation
# @!attribute [r] request_operation
# @return [OpenAPIParser::RequestOperation]
# @return [OpenAPIParser::SchemaValidator::Options]
def build_openapi_parser_path_option(validator_option)
coerce_value = validator_option.coerce_path_params
datetime_coerce_class = validator_option.coerce_date_times ? DateTime : nil
validate_header = validator_option.check_header
OpenAPIParser::SchemaValidator::Options.new(coerce_value: coerce_value,
datetime_coerce_class: datetime_coerce_class,
validate_header: validate_header)
end
# @return [OpenAPIParser::SchemaValidator::Options]
def build_openapi_parser_post_option(validator_option)
coerce_value = validator_option.coerce_form_params
datetime_coerce_class = validator_option.coerce_date_times ? DateTime : nil
validate_header = validator_option.check_header
OpenAPIParser::SchemaValidator::Options.new(coerce_value: coerce_value,
datetime_coerce_class: datetime_coerce_class,
validate_header: validate_header)
end
# @return [OpenAPIParser::SchemaValidator::Options]
def build_openapi_parser_get_option(validator_option)
coerce_value = validator_option.coerce_query_params
datetime_coerce_class = validator_option.coerce_date_times ? DateTime : nil
validate_header = validator_option.check_header
OpenAPIParser::SchemaValidator::Options.new(coerce_value: coerce_value,
datetime_coerce_class: datetime_coerce_class,
validate_header: validate_header)
end
def validate_get_request_params(params, headers, validator_option)
# bad performance because when we coerce value, same check
request_operation.validate_request_parameter(params, headers, build_openapi_parser_get_option(validator_option))
rescue OpenAPIParser::OpenAPIError => e
raise Committee::InvalidRequest.new(e.message)
end
def validate_post_request_params(params, headers, validator_option)
content_type = headers['Content-Type'].to_s.split(";").first.to_s
# bad performance because when we coerce value, same check
schema_validator_options = build_openapi_parser_post_option(validator_option)
request_operation.validate_request_parameter(params, headers, schema_validator_options)
request_operation.validate_request_body(content_type, params, schema_validator_options)
rescue => e
raise Committee::InvalidRequest.new(e.message)
end
def response_validate_options(strict, check_header)
::OpenAPIParser::SchemaValidator::ResponseValidateOptions.new(strict: strict, validate_header: check_header)
end
end
end
end
end
| 45.015038 | 123 | 0.663604 |
619fc8e7d38846ea73a8d2ff2d51991d50895992 | 1,764 | # frozen_string_literal: true
require 'spec_helper'
describe TrendingProject do
let(:user) { create(:user) }
let(:public_project1) { create(:project, :public) }
let(:public_project2) { create(:project, :public) }
let(:public_project3) { create(:project, :public) }
let(:private_project) { create(:project, :private) }
let(:internal_project) { create(:project, :internal) }
before do
3.times do
create(:note_on_commit, project: public_project1)
end
2.times do
create(:note_on_commit, project: public_project2)
end
create(:note_on_commit, project: public_project3, created_at: 5.weeks.ago)
create(:note_on_commit, project: private_project)
create(:note_on_commit, project: internal_project)
end
describe '.refresh!' do
before do
described_class.refresh!
end
it 'populates the trending projects table' do
expect(described_class.count).to eq(2)
end
it 'removes existing rows before populating the table' do
described_class.refresh!
expect(described_class.count).to eq(2)
end
it 'stores the project IDs for every trending project' do
rows = described_class.order(id: :asc).all
expect(rows[0].project_id).to eq(public_project1.id)
expect(rows[1].project_id).to eq(public_project2.id)
end
it 'does not store projects that fall out of the trending time range' do
expect(described_class.where(project_id: public_project3).any?).to eq(false)
end
it 'stores only public projects' do
expect(described_class.where(project_id: [public_project1.id, public_project2.id]).count).to eq(2)
expect(described_class.where(project_id: [private_project.id, internal_project.id]).count).to eq(0)
end
end
end
| 29.898305 | 105 | 0.706916 |
6affda77b595a122f904d1d67a75219e1d623cf9 | 1,215 | require 'spec_helper'
# mesos master service
describe 'mesos master service' do
it 'should be running' do
case RSpec.configuration.os
when 'Debian'
expect(service('mesos-master')).to be_running
end
end
end
describe port(5050) do
it { should be_listening }
end
describe command('curl -sD - http://localhost:5050/health -o /dev/null') do
its(:stdout) { should match(/200 OK/) }
end
describe file('/var/log/mesos/mesos-master.INFO') do
its(:content) { should match(/INFO level logging started/) }
its(:content) { should match(/Elected as the leading master!/) }
end
describe command('curl -sD - http://localhost:5050/state.json') do
its(:stdout) { should match(/"logging_level":"INFO"/) }
its(:stdout) { should match(/"cluster":"MyMesosCluster"/) }
its(:stdout) { should match(/"authenticate":"false"/) }
its(:stdout) { should match(/"authenticate_slaves":"false"/) }
its(:stdout) { should match(/"activated_slaves":\s*1/) }
end
describe file('/etc/mesos-chef/mesos-master') do
its(:content) { should contain 'exec 1> >\\(exec logger -p user.info -t "mesos-master"\\)' }
its(:content) { should contain 'exec 2> >\\(exec logger -p user.err -t "mesos-master"\\)' }
end
| 31.973684 | 94 | 0.678189 |
1d07b69b00b09d4672c1dde3b83c6d226d4f19d2 | 694 | # frozen_string_literal: true
require "test_helper"
module ActsAsAuthenticTest
class MagicColumnsTest < ActiveSupport::TestCase
def test_validates_numericality_of_login_count
u = User.new
u.login_count = -1
refute u.valid?
refute u.errors[:login_count].empty?
u.login_count = 0
refute u.valid?
assert u.errors[:login_count].empty?
end
def test_validates_numericality_of_failed_login_count
u = User.new
u.failed_login_count = -1
refute u.valid?
refute u.errors[:failed_login_count].empty?
u.failed_login_count = 0
refute u.valid?
assert u.errors[:failed_login_count].empty?
end
end
end
| 23.133333 | 57 | 0.690202 |
e2edb5a42eaae4ae14c82942a7230447077724d5 | 1,402 | # encoding: UTF-8
# This file is auto-generated from the current state of the database. Instead
# of editing this file, please use the migrations feature of Active Record to
# incrementally modify your database, and then regenerate this schema definition.
#
# Note that this schema.rb definition is the authoritative source for your
# database schema. If you need to create the application database on another
# system, you should be using db:schema:load, not running all the migrations
# from scratch. The latter is a flawed and unsustainable approach (the more migrations
# you'll amass, the slower it'll run and the greater likelihood for issues).
#
# It's strongly recommended that you check this file into your version control system.
ActiveRecord::Schema.define(version: 20160929042951) do
# These are extensions that must be enabled in order to support this database
enable_extension "plpgsql"
create_table "matchup_tables", force: :cascade do |t|
t.jsonb "matchups"
t.text "url"
t.float "max", default: 2.0
t.float "increment_value", default: 1.0
t.text "text"
t.text "link"
t.string "author"
t.datetime "created_at", null: false
t.datetime "updated_at", null: false
t.integer "visits", default: 0
t.boolean "default", default: false
end
end
| 41.235294 | 86 | 0.692582 |
18c0c37d1e563fe756d67139faeb7efecd11cca0 | 203 | Phccontactor::Engine.routes.draw do
# Message Routes
resources :messages, only: [:create]
get 'contact_us', to: 'messages#new'
# PHCAccounts Routes
mount Phcaccounts::Engine, :at => '/'
end
| 18.454545 | 39 | 0.689655 |
ed5be8d8e3024fe018a0d755e5b29d70078a1cbb | 1,015 | module Arcade
# Error handling
class Error < RuntimeError
end
class ArgumentError < ArgumentError
end
class SymbolError < ArgumentError
end
class LoadError < LoadError
end
class ImmutableError < RuntimeError
end
class RollbackError < RuntimeError
end
end # module Arcade
# Patching Object with universally accessible top level error method.
# The method is used throughout the lib instead of plainly raising exceptions.
# This allows lib user to easily inject user-specific error handling into the lib
# by just replacing Object#error method.
def error message, type=:standard, backtrace=nil
e = case type
when :standard
Arcade::Error.new message
when :args
Arcade::ArgumentError.new message
when :symbol
Arcade::SymbolError.new message
when :load
Arcade::LoadError.new message
when :immutable
Arcade::ImmutableError.new message
when :commit
Arcade::RollbackError.new message
end
e.set_backtrace(backtrace) if backtrace
raise e
end
| 21.595745 | 82 | 0.748768 |
6a64215ade8d291ba01d82283ed03d34e4a122bc | 1,922 | class Makefile2graph < Formula
desc "Create a graph of dependencies from GNU-Make"
homepage "https://github.com/lindenb/makefile2graph"
url "https://github.com/lindenb/makefile2graph/archive/v1.5.0.tar.gz"
sha256 "9464c6c1291609c211284a9889faedbab22ef504ce967b903630d57a27643b40"
license "MIT"
head "https://github.com/lindenb/makefile2graph.git"
bottle do
cellar :any_skip_relocation
sha256 "c8278a8691b682c5499295a79b73e18e18e87c879384b7d44dbcc0f70178ee58" => :big_sur
sha256 "af7dba0cbb045f067076706310b30c52eddbd6732e60d16017ccbfadd4bc866d" => :catalina
sha256 "5b5cb69a698628af41b3de70146580bbcb2e88a8b6d87d7fe9b4f58a2f2fdfb2" => :mojave
sha256 "51231ed0ef44fd31a10f4ea0a7500570181332786ddd5a8a9a886958ad1b1408" => :high_sierra
sha256 "274ee025c45df9757d608249d64105b9314c8e59fc52a81ad6906f807498b67c" => :sierra
sha256 "ed1939b1b0fd106f3e328e310a887cf454b81481f78fdf57ce75c0480a922d7d" => :el_capitan
sha256 "37aebae489e0f341f80417ec711e5c2817f5b8097c3493dcc11bc754bdd1b1cf" => :yosemite
sha256 "0de3d4a2492797c3259798493e287ac2403f02254c6cfcf74948a16bcc4bcd0d" => :mavericks
sha256 "d9cf1abfadeef69329bed8ebf251753f2aadb18f6955b8869a468a47b76b6f10" => :x86_64_linux
end
depends_on "graphviz"
def install
system "make"
# make test fails on CI. Error: fontconfig: Couldn't find font.
# It can be fixed with apt-get install fonts-dejavu-core
system "make", "test" unless ENV["CI"]
bin.install "make2graph", "makefile2graph"
man1.install "make2graph.1", "makefile2graph.1"
doc.install "LICENSE", "README.md", "screenshot.png"
end
test do
(testpath/"Makefile").write <<~EOS
all: foo
all: bar
foo: ook
bar: ook
ook:
EOS
system "make -Bnd >make-Bnd"
system "#{bin}/make2graph <make-Bnd"
system "#{bin}/make2graph --root <make-Bnd"
system "#{bin}/makefile2graph"
end
end
| 40.041667 | 94 | 0.759625 |
01fc5c3c65ceb7c1748b759a79892abef0a604da | 259 | require 'rails_helper'
RSpec.describe ReputationJob, type: :job do
let(:question) { create(:question) }
it 'calls ReputationJob' do
expect(Services::Reputation).to receive(:calculate).with(question)
ReputationJob.perform_now(question)
end
end
| 23.545455 | 70 | 0.745174 |
b9bc1abfbe228c7c63cc633cfdb68719539b6e89 | 4,962 | require "rails_helper"
RSpec.describe ResponsiblePersonAddressLog, type: :model do
describe "validations" do
subject(:address_log) { build_stubbed(:responsible_person_address_log) }
it "fails if a street address is not specified" do
address_log.line_1 = nil
expect(address_log.valid?).to be false
expect(address_log.errors[:line_1]).to include("Line 1 can not be blank")
end
it "fails if a city is not specified" do
address_log.city = nil
expect(address_log.valid?).to be false
expect(address_log.errors[:city]).to include("City can not be blank")
end
it "fails if a postal code is not specified" do
address_log.postal_code = nil
expect(address_log.valid?).to be false
expect(address_log.errors[:postal_code]).to include("Postal code can not be blank")
end
it "fails if postal code does not belong to UK" do
address_log.postal_code = "JJJJJ"
expect(address_log.valid?).to be false
expect(address_log.errors[:postal_code]).to include("Enter a UK postcode")
end
it "acepts the second line and county not being specified" do
address_log.line_2 = nil
address_log.county = nil
expect(address_log.valid?).to be true
end
it "fails if the end date is earlier than start date" do
address_log.start_date = Time.zone.local(2021, 7, 1)
address_log.end_date = Time.zone.local(2020, 5, 1)
expect(address_log.valid?).to be false
expect(address_log.errors[:end_date]).to include("End date must be after start date")
end
end
describe "end date set on callback" do
let(:current_time) { Time.zone.local(2021, 9, 3) }
before { travel_to current_time }
after { travel_back }
it "autopopulates the end date to the current time when not provided" do
address_log = build_stubbed(:responsible_person_address_log, end_date: nil)
address_log.validate
expect(address_log.end_date).to eq(Time.zone.now)
end
it "keeps the given end date when provided" do
given_date = Time.zone.local(2021, 8, 1)
address_log = build_stubbed(:responsible_person_address_log, end_date: given_date)
address_log.validate
expect(address_log.end_date).to eq(given_date)
end
end
describe "start date set on callback" do
let(:responsible_person) { create(:responsible_person, created_at: Time.zone.local(2021, 7, 1)) }
context "when there where other previous addresses associated with the responsible person" do
before do
create(:responsible_person_address_log,
responsible_person: responsible_person,
start_date: Time.zone.local(2021, 7, 1),
end_date: Time.zone.local(2021, 8, 1))
create(:responsible_person_address_log,
responsible_person: responsible_person,
start_date: Time.zone.local(2021, 8, 1),
end_date: Time.zone.local(2021, 9, 1))
end
it "populates the start date with the last previous address end date" do
address_log = build_stubbed(:responsible_person_address_log,
responsible_person: responsible_person,
start_date: nil)
address_log.validate
expect(address_log.start_date).to eq(Time.zone.local(2021, 9, 1))
end
end
context "when there aren't previous addresses associated with the responsible person" do
it "populates the start date with the Responsible Person creation date" do
address_log = build_stubbed(:responsible_person_address_log,
responsible_person: responsible_person,
start_date: nil)
address_log.validate
expect(address_log.start_date).to eq(responsible_person.created_at)
end
end
end
describe "#to_s" do
# rubocop:disable RSpec/ExampleLength
it "returns the address in a human readable format" do
address_log = build_stubbed(:responsible_person_address_log,
line_1: "Office name",
line_2: "123 Street",
city: "London",
county: "Greater London",
postal_code: "SW1A 1AA")
expect(address_log.to_s).to eq("Office name, 123 Street, London, Greater London, SW1A 1AA")
end
it "does not include empty fields" do
address_log = build_stubbed(:responsible_person_address_log,
line_1: "Office name",
line_2: nil,
city: "London",
county: nil,
postal_code: "SW1A 1AA")
expect(address_log.to_s).to eq("Office name, London, SW1A 1AA")
end
# rubocop:enable RSpec/ExampleLength
end
end
| 38.169231 | 101 | 0.631802 |
6abf73dfe6fc55e048b8bd47dbf41d106dc06e08 | 241 | # frozen_string_literal: true
organization_name = 'IKIA'
puts "Running seeds for organization #{organization_name}"
organization = Organization.find_by(name: organization_name)
organization ||= Organization.create!(name: organization_name)
| 34.428571 | 62 | 0.817427 |
08c9b563da652f7e5687d5ae64edda361213e8db | 347 | require 'raven'
require 'raven/integrations/rack'
require 'sinatra/base'
module Travis
module Api
module Build
class Sentry < Sinatra::Base
configure do
Raven.configure do |config|
config.tags = { environment: environment }
end
use Raven::Rack
end
end
end
end
end
| 18.263158 | 54 | 0.596542 |
91fb637525414c505eddc6794bc81fcc754843cd | 473 | module ConsoleUtils #:nodoc:
module ActiveRecordUtils
extend ActiveSupport::Autoload
autoload :RandomRecord
def self.extended(mod)
ActiveSupport.on_load(:active_record) do
ActiveRecord::Relation.send(:prepend, RandomRecord::FinderMethods)
ActiveRecord::Base.send(:extend, RandomRecord::Querying)
end
end
# Shortcut to <tt>ConsoleUtils.find_user(id)</tt>
def usr(id)
ConsoleUtils.find_user(id)
end
end
end | 24.894737 | 74 | 0.699789 |
337e953200abb49adf515d3a65d9f258d99dd1b5 | 451 | Puppet::Type.newtype(:swift_ring_build_helper) do
@doc = "Base resource definition for building swift rings"
ensurable
newparam(:name) do
desc "A unique name for the resource"
end
newproperty(:swift_storage_ips, :array_matching => :all) do
desc "an array of the ip addresses of the swift storage nodes"
end
newproperty(:swift_storage_device) do
desc "the name of the storage device on each swift node"
end
end
| 23.736842 | 70 | 0.720621 |
1d56f1b059a9ace139c09240b8547106d0e2dc20 | 431 | cask 'thedesk' do
version '18.7.1'
sha256 '0e92ed2ab9b61fe9b113ae3c90af9e90281f83f1c76af2aca53a8ccda3016252'
# github.com/cutls/TheDesk was verified as official when first introduced to the cask
url "https://github.com/cutls/TheDesk/releases/download/v#{version}/TheDesk-#{version}.dmg"
appcast 'https://github.com/cutls/TheDesk/releases.atom'
name 'TheDesk'
homepage 'https://thedesk.top/'
app 'TheDesk.app'
end
| 33.153846 | 93 | 0.763341 |
ed3286180299a63d1bba5508a52c173c19be56f6 | 3,271 | require 'tempfile'
require 'fileutils'
require 'galaxy/filter'
require 'galaxy/temp'
require 'galaxy/transport'
require 'galaxy/version'
require 'galaxy/versioning'
module Helper
def Helper.mk_tmpdir
Galaxy::Temp.mk_auto_dir "testing"
end
class Mock
def initialize listeners={}
@listeners = listeners
end
def method_missing sym, *args
f = @listeners[sym]
if f
f.call(*args)
end
end
end
end
class MockConsole
def initialize agents
@agents = agents
end
def shutdown
end
def agents filters = { :set => :all }
filter = Galaxy::Filter.new filters
@agents.select(&filter)
end
end
class MockAgent
attr_reader :agent_id, :agent_group, :config_path, :stopped, :started, :restarted
attr_reader :gonsole_url, :env, :version, :type, :url, :agent_status, :proxy, :build, :core_type, :machine, :ip
attr_reader :build_version
def initialize agent_id, agent_group, url, env = nil, version = nil, type = nil, gonsole_url=nil
@agent_id = agent_id
@agent_group = agent_group
@env = env
@version = version
@type = type
@gonsole_url = gonsole_url
@stopped = @started = @restarted = false
@url = url
Galaxy::Transport.publish @url, self
@config_path = nil
@config_path = "/#{env}/#{version}/#{type}" unless env.nil? || version.nil? || type.nil?
@agent_status = 'online'
@status = 'online'
@proxy = Galaxy::Transport.locate(@url)
@build = "1.2.3"
@core_type = 'test'
@ip = nil
@drb_url = nil
@os = nil
@machine = nil
@build_version = nil
end
def shutdown
Galaxy::Transport.unpublish @url
end
def status
OpenStruct.new(
:agent_id => @agent_id,
:agent_group => @agent_group,
:url => @drb_url,
:os => @os,
:machine => @machine,
:core_type => @core_type,
:config_path => @config_path,
:build => @build,
:status => @status,
:agent_status => 'online',
:galaxy_version => Galaxy::Version
)
end
def stop!
@stopped = true
status
end
def start!
@started = true
status
end
def restart!
@restarted = true
status
end
def become! req_build_version, path, config_uri=nil, binaries_uri=nil, versioning_policy = Galaxy::Versioning::StrictVersioningPolicy
md = %r!^/([^/]+)/([^/]+)/(.*)$!.match path
new_env, new_version, new_type = md[1], md[2], md[3]
# XXX We don't test the versioning code - but it should go away soon
#raise if @version == new_version
@env = new_env
@version = new_version
@type = new_type
@config_path = "/#{@env}/#{@version}/#{@type}"
@build_version = req_build_version
status
end
def update_config! new_version, config_uri=nil, binaries_uri=nil, versioning_policy = Galaxy::Versioning::StrictVersioningPolicy
# XXX We don't test the versioning code - but it should go away soon
#raise if @version == new_version
@version = new_version
@config_path = "/#{@env}/#{@version}/#{@type}"
status
end
def check_credentials!(command, credentials)
true
end
def inspect
Galaxy::Client::SoftwareDeploymentReport.new.record_result(self)
end
end
| 23.035211 | 135 | 0.631611 |
38747e0aadf44158e476883d1fb8166437a2f980 | 15,377 | # typed: false
# frozen_string_literal: true
require "cmd/shared_examples/args_parse"
require "dev-cmd/bottle"
describe "Homebrew.bottle_args" do
it_behaves_like "parseable arguments"
end
describe "brew bottle", :integration_test do
it "builds a bottle for the given Formula" do
# create stub patchelf
if OS.linux?
setup_test_formula "patchelf"
patchelf = HOMEBREW_CELLAR/"patchelf/1.0/bin/patchelf"
patchelf.dirname.mkpath
patchelf.write <<~EOS
#!/bin/sh
exit 0
EOS
FileUtils.chmod "+x", patchelf
FileUtils.ln_s patchelf, HOMEBREW_PREFIX/"bin/patchelf"
end
install_test_formula "testball", build_bottle: true
# `brew bottle` should not fail with dead symlink
# https://github.com/Homebrew/legacy-homebrew/issues/49007
(HOMEBREW_CELLAR/"testball/0.1").cd do
FileUtils.ln_s "not-exist", "symlink"
end
begin
expect { brew "bottle", "--no-rebuild", "testball" }
.to output(/testball--0\.1.*\.bottle\.tar\.gz/).to_stdout
.and not_to_output.to_stderr
.and be_a_success
ensure
FileUtils.rm_f Dir.glob("testball--0.1*.bottle.tar.gz")
end
end
end
def stub_hash(parameters)
<<~EOS
{
"#{parameters[:name]}":{
"formula":{
"pkg_version":"#{parameters[:version]}",
"path":"#{parameters[:path]}"
},
"bottle":{
"root_url":"#{HOMEBREW_BOTTLE_DEFAULT_DOMAIN}",
"prefix":"/usr/local",
"cellar":"#{parameters[:cellar]}",
"rebuild":0,
"tags":{
"#{parameters[:os]}":{
"filename":"#{parameters[:filename]}",
"local_filename":"#{parameters[:local_filename]}",
"sha256":"#{parameters[:sha256]}"
}
}
},
"bintray":{
"package":"#{parameters[:name]}",
"repository":"bottles"
}
}
}
EOS
end
describe Homebrew do
subject(:homebrew) { described_class }
let(:hello_hash_big_sur) {
JSON.parse(
stub_hash(
{
"name": "hello",
"version": "1.0",
"path": "/home/hello.rb",
"cellar": "any_skip_relocation",
"os": "big_sur",
"filename": "hello-1.0.big_sur.bottle.tar.gz",
"local_filename": "hello--1.0.big_sur.bottle.tar.gz",
"sha256": "a0af7dcbb5c83f6f3f7ecd507c2d352c1a018f894d51ad241ce8492fa598010f",
},
),
)
}
let(:hello_hash_catalina) {
JSON.parse(
stub_hash(
{
"name": "hello",
"version": "1.0",
"path": "/home/hello.rb",
"cellar": "any_skip_relocation",
"os": "catalina",
"filename": "hello-1.0.catalina.bottle.tar.gz",
"local_filename": "hello--1.0.catalina.bottle.tar.gz",
"sha256": "5334dd344986e46b2aa4f0471cac7b0914bd7de7cb890a34415771788d03f2ac",
},
),
)
}
let(:unzip_hash_big_sur) {
JSON.parse(
stub_hash(
{
"name": "unzip",
"version": "2.0",
"path": "/home/unzip.rb",
"cellar": "any_skip_relocation",
"os": "big_sur",
"filename": "unzip-2.0.big_sur.bottle.tar.gz",
"local_filename": "unzip--2.0.big_sur.bottle.tar.gz",
"sha256": "16cf230afdfcb6306c208d169549cf8773c831c8653d2c852315a048960d7e72",
},
),
)
}
let(:unzip_hash_catalina) {
JSON.parse(
stub_hash(
{
"name": "unzip",
"version": "2.0",
"path": "/home/unzip.rb",
"cellar": "any",
"os": "catalina",
"filename": "unzip-2.0.catalina.bottle.tar.gz",
"local_filename": "unzip--2.0.catalina.bottle.tar.gz",
"sha256": "d9cc50eec8ac243148a121049c236cba06af4a0b1156ab397d0a2850aa79c137",
},
),
)
}
specify "::parse_json_files" do
Tempfile.open("hello--1.0.big_sur.bottle.json") do |f|
f.write(
stub_hash(
{
"name": "hello",
"version": "1.0",
"path": "/home/hello.rb",
"cellar": "any_skip_relocation",
"os": "big_sur",
"filename": "hello-1.0.big_sur.bottle.tar.gz",
"local_filename": "hello--1.0.big_sur.bottle.tar.gz",
"sha256": "a0af7dcbb5c83f6f3f7ecd507c2d352c1a018f894d51ad241ce8492fa598010f",
},
),
)
f.close
expect(
homebrew.parse_json_files([f.path]).first["hello"]["bottle"]["tags"]["big_sur"]["filename"],
).to eq("hello-1.0.big_sur.bottle.tar.gz")
end
end
specify "::merge_json_files" do
bottles_hash = homebrew.merge_json_files(
[hello_hash_big_sur, hello_hash_catalina, unzip_hash_big_sur, unzip_hash_catalina],
)
hello_hash = bottles_hash["hello"]
expect(hello_hash["bottle"]["cellar"]).to eq("any_skip_relocation")
expect(hello_hash["bottle"]["tags"]["big_sur"]["filename"]).to eq("hello-1.0.big_sur.bottle.tar.gz")
expect(hello_hash["bottle"]["tags"]["big_sur"]["local_filename"]).to eq("hello--1.0.big_sur.bottle.tar.gz")
expect(hello_hash["bottle"]["tags"]["big_sur"]["sha256"]).to eq(
"a0af7dcbb5c83f6f3f7ecd507c2d352c1a018f894d51ad241ce8492fa598010f",
)
expect(hello_hash["bottle"]["tags"]["catalina"]["filename"]).to eq("hello-1.0.catalina.bottle.tar.gz")
expect(hello_hash["bottle"]["tags"]["catalina"]["local_filename"]).to eq("hello--1.0.catalina.bottle.tar.gz")
expect(hello_hash["bottle"]["tags"]["catalina"]["sha256"]).to eq(
"5334dd344986e46b2aa4f0471cac7b0914bd7de7cb890a34415771788d03f2ac",
)
unzip_hash = bottles_hash["unzip"]
expect(unzip_hash["bottle"]["cellar"]).to eq("any")
expect(unzip_hash["bottle"]["tags"]["big_sur"]["filename"]).to eq("unzip-2.0.big_sur.bottle.tar.gz")
expect(unzip_hash["bottle"]["tags"]["big_sur"]["local_filename"]).to eq("unzip--2.0.big_sur.bottle.tar.gz")
expect(unzip_hash["bottle"]["tags"]["big_sur"]["sha256"]).to eq(
"16cf230afdfcb6306c208d169549cf8773c831c8653d2c852315a048960d7e72",
)
expect(unzip_hash["bottle"]["tags"]["catalina"]["filename"]).to eq("unzip-2.0.catalina.bottle.tar.gz")
expect(unzip_hash["bottle"]["tags"]["catalina"]["local_filename"]).to eq("unzip--2.0.catalina.bottle.tar.gz")
expect(unzip_hash["bottle"]["tags"]["catalina"]["sha256"]).to eq(
"d9cc50eec8ac243148a121049c236cba06af4a0b1156ab397d0a2850aa79c137",
)
end
end
describe "brew bottle --merge", :integration_test, :needs_linux do
let(:core_tap) { CoreTap.new }
let(:tarball) do
if OS.linux?
TEST_FIXTURE_DIR/"tarballs/testball-0.1-linux.tbz"
else
TEST_FIXTURE_DIR/"tarballs/testball-0.1.tbz"
end
end
before do
Pathname("testball-1.0.big_sur.bottle.json").write stub_hash(
"name": "testball",
"version": "1.0",
"path": "#{core_tap.path}/Formula/testball.rb",
"cellar": "any_skip_relocation",
"os": "big_sur",
"filename": "hello-1.0.big_sur.bottle.tar.gz",
"local_filename": "hello--1.0.big_sur.bottle.tar.gz",
"sha256": "a0af7dcbb5c83f6f3f7ecd507c2d352c1a018f894d51ad241ce8492fa598010f",
)
Pathname("testball-1.0.catalina.bottle.json").write stub_hash(
"name": "testball",
"version": "1.0",
"path": "#{core_tap.path}/Formula/testball.rb",
"cellar": "any_skip_relocation",
"os": "catalina",
"filename": "testball-1.0.catalina.bottle.tar.gz",
"local_filename": "testball--1.0.catalina.bottle.tar.gz",
"sha256": "5334dd344986e46b2aa4f0471cac7b0914bd7de7cb890a34415771788d03f2ac",
)
end
after do
FileUtils.rm_f "testball-1.0.catalina.bottle.json"
FileUtils.rm_f "testball-1.0.big_sur.bottle.json"
end
it "adds the bottle block to a formula that has none" do
core_tap.path.cd do
system "git", "init"
setup_test_formula "testball"
system "git", "add", "--all"
system "git", "commit", "-m", "testball 0.1"
end
expect {
brew "bottle",
"--merge",
"--write",
"testball-1.0.big_sur.bottle.json",
"testball-1.0.catalina.bottle.json"
}.to output(
<<~EOS,
==> testball
bottle do
root_url "#{HOMEBREW_BOTTLE_DEFAULT_DOMAIN}"
cellar :any_skip_relocation
sha256 "a0af7dcbb5c83f6f3f7ecd507c2d352c1a018f894d51ad241ce8492fa598010f" => :big_sur
sha256 "5334dd344986e46b2aa4f0471cac7b0914bd7de7cb890a34415771788d03f2ac" => :catalina
end
EOS
).to_stdout
expect((core_tap.path/"Formula/testball.rb").read).to eq(
<<~EOS,
class Testball < Formula
desc "Some test"
homepage "https://brew.sh/testball"
url "file://#{tarball}"
sha256 "#{tarball.sha256}"
bottle do
root_url "#{HOMEBREW_BOTTLE_DEFAULT_DOMAIN}"
cellar :any_skip_relocation
sha256 "a0af7dcbb5c83f6f3f7ecd507c2d352c1a018f894d51ad241ce8492fa598010f" => :big_sur
sha256 "5334dd344986e46b2aa4f0471cac7b0914bd7de7cb890a34415771788d03f2ac" => :catalina
end
option "with-foo", "Build with foo"
def install
(prefix/"foo"/"test").write("test") if build.with? "foo"
prefix.install Dir["*"]
(buildpath/"test.c").write \
"#include <stdio.h>\\nint main(){printf(\\"test\\");return 0;}"
bin.mkpath
system ENV.cc, "test.c", "-o", bin/"test"
end
# something here
end
EOS
)
end
it "replaces the bottle block in a formula that already has a bottle block" do
core_tap.path.cd do
system "git", "init"
bottle_block = <<~EOS
bottle do
root_url "#{HOMEBREW_BOTTLE_DEFAULT_DOMAIN}"
cellar :any_skip_relocation
sha256 "6b276491297d4052538bd2fd22d5129389f27d90a98f831987236a5b90511b98" => :big_sur
sha256 "16cf230afdfcb6306c208d169549cf8773c831c8653d2c852315a048960d7e72" => :catalina
end
EOS
setup_test_formula("testball", "", bottle_block)
system "git", "add", "--all"
system "git", "commit", "-m", "testball 0.1"
end
expect {
brew "bottle",
"--merge",
"--write",
"testball-1.0.big_sur.bottle.json",
"testball-1.0.catalina.bottle.json"
}.to output(
<<~EOS,
==> testball
bottle do
root_url "#{HOMEBREW_BOTTLE_DEFAULT_DOMAIN}"
cellar :any_skip_relocation
sha256 "a0af7dcbb5c83f6f3f7ecd507c2d352c1a018f894d51ad241ce8492fa598010f" => :big_sur
sha256 "5334dd344986e46b2aa4f0471cac7b0914bd7de7cb890a34415771788d03f2ac" => :catalina
end
EOS
).to_stdout
expect((core_tap.path/"Formula/testball.rb").read).to eq(
<<~EOS,
class Testball < Formula
desc "Some test"
homepage "https://brew.sh/testball"
url "file://#{tarball}"
sha256 "#{tarball.sha256}"
option "with-foo", "Build with foo"
bottle do
root_url "#{HOMEBREW_BOTTLE_DEFAULT_DOMAIN}"
cellar :any_skip_relocation
sha256 "a0af7dcbb5c83f6f3f7ecd507c2d352c1a018f894d51ad241ce8492fa598010f" => :big_sur
sha256 "5334dd344986e46b2aa4f0471cac7b0914bd7de7cb890a34415771788d03f2ac" => :catalina
end
def install
(prefix/"foo"/"test").write("test") if build.with? "foo"
prefix.install Dir["*"]
(buildpath/"test.c").write \
"#include <stdio.h>\\nint main(){printf(\\"test\\");return 0;}"
bin.mkpath
system ENV.cc, "test.c", "-o", bin/"test"
end
# something here
end
EOS
)
end
it "fails to add the bottle block to a formula that has no bottle block when using --keep-old" do
core_tap.path.cd do
system "git", "init"
setup_test_formula("testball")
system "git", "add", "--all"
system "git", "commit", "-m", "testball 0.1"
end
expect {
brew "bottle",
"--merge",
"--write",
"--keep-old",
"testball-1.0.big_sur.bottle.json",
"testball-1.0.catalina.bottle.json"
}.to output("Error: --keep-old was passed but there was no existing bottle block!\n").to_stderr
end
it "updates the bottle block in a formula that already has a bottle block when using --keep-old" do
core_tap.path.cd do
system "git", "init"
bottle_block = <<~EOS
bottle do
root_url "#{HOMEBREW_BOTTLE_DEFAULT_DOMAIN}"
cellar :any_skip_relocation
sha256 "6971b6eebf4c00eaaed72a1104a49be63861eabc95d679a0c84040398e320059" => :high_sierra
end
EOS
setup_test_formula("testball", "", bottle_block)
system "git", "add", "--all"
system "git", "commit", "-m", "testball 0.1"
end
expect {
brew "bottle",
"--merge",
"--write",
"--keep-old",
"testball-1.0.big_sur.bottle.json",
"testball-1.0.catalina.bottle.json"
}.to output(
<<~EOS,
==> testball
bottle do
root_url "#{HOMEBREW_BOTTLE_DEFAULT_DOMAIN}"
cellar :any_skip_relocation
sha256 "a0af7dcbb5c83f6f3f7ecd507c2d352c1a018f894d51ad241ce8492fa598010f" => :big_sur
sha256 "5334dd344986e46b2aa4f0471cac7b0914bd7de7cb890a34415771788d03f2ac" => :catalina
sha256 "6971b6eebf4c00eaaed72a1104a49be63861eabc95d679a0c84040398e320059" => :high_sierra
end
EOS
).to_stdout
expect((core_tap.path/"Formula/testball.rb").read).to eq(
<<~EOS,
class Testball < Formula
desc "Some test"
homepage "https://brew.sh/testball"
url "file://#{tarball}"
sha256 "#{tarball.sha256}"
option "with-foo", "Build with foo"
bottle do
root_url "#{HOMEBREW_BOTTLE_DEFAULT_DOMAIN}"
cellar :any_skip_relocation
sha256 "a0af7dcbb5c83f6f3f7ecd507c2d352c1a018f894d51ad241ce8492fa598010f" => :big_sur
sha256 "5334dd344986e46b2aa4f0471cac7b0914bd7de7cb890a34415771788d03f2ac" => :catalina
sha256 "6971b6eebf4c00eaaed72a1104a49be63861eabc95d679a0c84040398e320059" => :high_sierra
end
def install
(prefix/"foo"/"test").write("test") if build.with? "foo"
prefix.install Dir["*"]
(buildpath/"test.c").write \
"#include <stdio.h>\\nint main(){printf(\\"test\\");return 0;}"
bin.mkpath
system ENV.cc, "test.c", "-o", bin/"test"
end
# something here
end
EOS
)
end
end
| 33.574236 | 113 | 0.577876 |
211d3d847f2cac162306cb58b38db39d0ed2ba5b | 23,435 | require 'spec_helper'
describe GitPushService, services: true do
include RepoHelpers
let(:user) { create(:user) }
let(:project) { create(:project, :repository) }
before do
project.team << [user, :master]
@blankrev = Gitlab::Git::BLANK_SHA
@oldrev = sample_commit.parent_id
@newrev = sample_commit.id
@ref = 'refs/heads/master'
end
describe 'Push branches' do
let(:oldrev) { @oldrev }
let(:newrev) { @newrev }
subject do
execute_service(project, user, oldrev, newrev, @ref )
end
context 'new branch' do
let(:oldrev) { @blankrev }
it { is_expected.to be_truthy }
it 'calls the after_push_commit hook' do
expect(project.repository).to receive(:after_push_commit).with('master')
subject
end
it 'calls the after_create_branch hook' do
expect(project.repository).to receive(:after_create_branch)
subject
end
end
context 'existing branch' do
it { is_expected.to be_truthy }
it 'calls the after_push_commit hook' do
expect(project.repository).to receive(:after_push_commit).with('master')
subject
end
end
context 'rm branch' do
let(:newrev) { @blankrev }
it { is_expected.to be_truthy }
it 'calls the after_push_commit hook' do
expect(project.repository).to receive(:after_push_commit).with('master')
subject
end
it 'calls the after_remove_branch hook' do
expect(project.repository).to receive(:after_remove_branch)
subject
end
end
end
describe "Git Push Data" do
before do
service = execute_service(project, user, @oldrev, @newrev, @ref )
@push_data = service.push_data
@commit = project.commit(@newrev)
end
subject { @push_data }
it { is_expected.to include(object_kind: 'push') }
it { is_expected.to include(before: @oldrev) }
it { is_expected.to include(after: @newrev) }
it { is_expected.to include(ref: @ref) }
it { is_expected.to include(user_id: user.id) }
it { is_expected.to include(user_name: user.name) }
it { is_expected.to include(project_id: project.id) }
context "with repository data" do
subject { @push_data[:repository] }
it { is_expected.to include(name: project.name) }
it { is_expected.to include(url: project.url_to_repo) }
it { is_expected.to include(description: project.description) }
it { is_expected.to include(homepage: project.web_url) }
end
context "with commits" do
subject { @push_data[:commits] }
it { is_expected.to be_an(Array) }
it 'has 1 element' do
expect(subject.size).to eq(1)
end
context "the commit" do
subject { @push_data[:commits].first }
it { is_expected.to include(id: @commit.id) }
it { is_expected.to include(message: @commit.safe_message) }
it { is_expected.to include(timestamp: @commit.date.xmlschema) }
it do
is_expected.to include(
url: [
Gitlab.config.gitlab.url,
project.namespace.to_param,
project.to_param,
'commit',
@commit.id
].join('/')
)
end
context "with a author" do
subject { @push_data[:commits].first[:author] }
it { is_expected.to include(name: @commit.author_name) }
it { is_expected.to include(email: @commit.author_email) }
end
end
end
end
describe "ES indexing" do
before do
stub_application_setting(elasticsearch_search: true, elasticsearch_indexing: true)
end
after do
stub_application_setting(elasticsearch_search: false, elasticsearch_indexing: false)
end
it "does not trigger indexer when push to non-default branch" do
expect_any_instance_of(Gitlab::Elastic::Indexer).not_to receive(:run)
execute_service(project, user, @oldrev, @newrev, 'refs/heads/other')
end
it "triggers indexer when push to default branch" do
expect_any_instance_of(Gitlab::Elastic::Indexer).to receive(:run)
execute_service(project, user, @oldrev, @newrev, 'refs/heads/master')
end
end
describe "Push Event" do
before do
service = execute_service(project, user, @oldrev, @newrev, @ref )
@event = Event.find_by_action(Event::PUSHED)
@push_data = service.push_data
end
it { expect(@event).not_to be_nil }
it { expect(@event.project).to eq(project) }
it { expect(@event.action).to eq(Event::PUSHED) }
it { expect(@event.data).to eq(@push_data) }
context "Updates merge requests" do
it "when pushing a new branch for the first time" do
expect(UpdateMergeRequestsWorker).to receive(:perform_async).
with(project.id, user.id, @blankrev, 'newrev', 'refs/heads/master')
execute_service(project, user, @blankrev, 'newrev', 'refs/heads/master' )
end
end
context "Sends System Push data" do
it "when pushing on a branch" do
expect(SystemHookPushWorker).to receive(:perform_async).with(@push_data, :push_hooks)
execute_service(project, user, @oldrev, @newrev, @ref )
end
end
end
describe "Updates git attributes" do
context "for default branch" do
it "calls the copy attributes method for the first push to the default branch" do
expect(project.repository).to receive(:copy_gitattributes).with('master')
execute_service(project, user, @blankrev, 'newrev', 'refs/heads/master')
end
it "calls the copy attributes method for changes to the default branch" do
expect(project.repository).to receive(:copy_gitattributes).with('refs/heads/master')
execute_service(project, user, 'oldrev', 'newrev', 'refs/heads/master')
end
end
context "for non-default branch" do
before do
# Make sure the "default" branch is different
allow(project).to receive(:default_branch).and_return('not-master')
end
it "does not call copy attributes method" do
expect(project.repository).not_to receive(:copy_gitattributes)
execute_service(project, user, @oldrev, @newrev, @ref)
end
end
end
describe "Webhooks" do
context "execute webhooks" do
it "when pushing a branch for the first time" do
expect(project).to receive(:execute_hooks)
expect(project.default_branch).to eq("master")
execute_service(project, user, @blankrev, 'newrev', 'refs/heads/master' )
expect(project.protected_branches).not_to be_empty
expect(project.protected_branches.first.push_access_levels.map(&:access_level)).to eq([Gitlab::Access::MASTER])
expect(project.protected_branches.first.merge_access_levels.map(&:access_level)).to eq([Gitlab::Access::MASTER])
end
it "when pushing a branch for the first time with default branch protection disabled" do
stub_application_setting(default_branch_protection: Gitlab::Access::PROTECTION_NONE)
expect(project).to receive(:execute_hooks)
expect(project.default_branch).to eq("master")
execute_service(project, user, @blankrev, 'newrev', 'refs/heads/master' )
expect(project.protected_branches).to be_empty
end
it "when pushing a branch for the first time with default branch protection set to 'developers can push'" do
stub_application_setting(default_branch_protection: Gitlab::Access::PROTECTION_DEV_CAN_PUSH)
expect(project).to receive(:execute_hooks)
expect(project.default_branch).to eq("master")
execute_service(project, user, @blankrev, 'newrev', 'refs/heads/master' )
expect(project.protected_branches).not_to be_empty
expect(project.protected_branches.last.push_access_levels.map(&:access_level)).to eq([Gitlab::Access::DEVELOPER])
expect(project.protected_branches.last.merge_access_levels.map(&:access_level)).to eq([Gitlab::Access::MASTER])
end
it "when pushing a branch for the first time with an existing branch permission configured" do
stub_application_setting(default_branch_protection: Gitlab::Access::PROTECTION_DEV_CAN_PUSH)
create(:protected_branch, :no_one_can_push, :developers_can_merge,
:remove_default_access_levels,
project: project, name: 'master')
expect(project).to receive(:execute_hooks)
expect(project.default_branch).to eq("master")
expect_any_instance_of(ProtectedBranches::CreateService).not_to receive(:execute)
execute_service(project, user, @blankrev, 'newrev', 'refs/heads/master' )
expect(project.protected_branches).not_to be_empty
expect(project.protected_branches.last.push_access_levels.map(&:access_level)).to eq([Gitlab::Access::NO_ACCESS])
expect(project.protected_branches.last.merge_access_levels.map(&:access_level)).to eq([Gitlab::Access::DEVELOPER])
end
it "when pushing a branch for the first time with default branch protection set to 'developers can merge'" do
stub_application_setting(default_branch_protection: Gitlab::Access::PROTECTION_DEV_CAN_MERGE)
expect(project).to receive(:execute_hooks)
expect(project.default_branch).to eq("master")
execute_service(project, user, @blankrev, 'newrev', 'refs/heads/master' )
expect(project.protected_branches).not_to be_empty
expect(project.protected_branches.first.push_access_levels.map(&:access_level)).to eq([Gitlab::Access::MASTER])
expect(project.protected_branches.first.merge_access_levels.map(&:access_level)).to eq([Gitlab::Access::DEVELOPER])
end
it "when pushing new commits to existing branch" do
expect(project).to receive(:execute_hooks)
execute_service(project, user, 'oldrev', 'newrev', 'refs/heads/master' )
end
end
end
describe "cross-reference notes" do
let(:issue) { create :issue, project: project }
let(:commit_author) { create :user }
let(:commit) { project.commit }
before do
project.team << [commit_author, :developer]
project.team << [user, :developer]
allow(commit).to receive_messages(
safe_message: "this commit \n mentions #{issue.to_reference}",
references: [issue],
author_name: commit_author.name,
author_email: commit_author.email
)
allow_any_instance_of(ProcessCommitWorker).to receive(:build_commit).
and_return(commit)
allow(project.repository).to receive(:commits_between).and_return([commit])
end
it "creates a note if a pushed commit mentions an issue" do
expect(SystemNoteService).to receive(:cross_reference).with(issue, commit, commit_author)
execute_service(project, user, @oldrev, @newrev, @ref )
end
it "only creates a cross-reference note if one doesn't already exist" do
SystemNoteService.cross_reference(issue, commit, user)
expect(SystemNoteService).not_to receive(:cross_reference).with(issue, commit, commit_author)
execute_service(project, user, @oldrev, @newrev, @ref )
end
it "defaults to the pushing user if the commit's author is not known" do
allow(commit).to receive_messages(
author_name: 'unknown name',
author_email: '[email protected]'
)
expect(SystemNoteService).to receive(:cross_reference).with(issue, commit, user)
execute_service(project, user, @oldrev, @newrev, @ref )
end
it "finds references in the first push to a non-default branch" do
allow(project.repository).to receive(:commits_between).with(@blankrev, @newrev).and_return([])
allow(project.repository).to receive(:commits_between).with("master", @newrev).and_return([commit])
expect(SystemNoteService).to receive(:cross_reference).with(issue, commit, commit_author)
execute_service(project, user, @blankrev, @newrev, 'refs/heads/other' )
end
end
describe "issue metrics" do
let(:issue) { create :issue, project: project }
let(:commit_author) { create :user }
let(:commit) { project.commit }
let(:commit_time) { Time.now }
before do
project.team << [commit_author, :developer]
project.team << [user, :developer]
allow(commit).to receive_messages(
safe_message: "this commit \n mentions #{issue.to_reference}",
references: [issue],
author_name: commit_author.name,
author_email: commit_author.email,
committed_date: commit_time
)
allow_any_instance_of(ProcessCommitWorker).to receive(:build_commit).
and_return(commit)
allow(project.repository).to receive(:commits_between).and_return([commit])
end
context "while saving the 'first_mentioned_in_commit_at' metric for an issue" do
it 'sets the metric for referenced issues' do
execute_service(project, user, @oldrev, @newrev, @ref)
expect(issue.reload.metrics.first_mentioned_in_commit_at).to be_like_time(commit_time)
end
it 'does not set the metric for non-referenced issues' do
non_referenced_issue = create(:issue, project: project)
execute_service(project, user, @oldrev, @newrev, @ref)
expect(non_referenced_issue.reload.metrics.first_mentioned_in_commit_at).to be_nil
end
end
end
describe "closing issues from pushed commits containing a closing reference" do
let(:issue) { create :issue, project: project }
let(:other_issue) { create :issue, project: project }
let(:commit_author) { create :user }
let(:closing_commit) { project.commit }
before do
allow(closing_commit).to receive_messages(
issue_closing_regex: /^([Cc]loses|[Ff]ixes) #\d+/,
safe_message: "this is some work.\n\ncloses ##{issue.iid}",
author_name: commit_author.name,
author_email: commit_author.email
)
allow(project.repository).to receive(:commits_between).
and_return([closing_commit])
allow_any_instance_of(ProcessCommitWorker).to receive(:build_commit).
and_return(closing_commit)
project.team << [commit_author, :master]
end
context "to default branches" do
it "closes issues" do
execute_service(project, commit_author, @oldrev, @newrev, @ref )
expect(Issue.find(issue.id)).to be_closed
end
it "adds a note indicating that the issue is now closed" do
expect(SystemNoteService).to receive(:change_status).with(issue, project, commit_author, "closed", closing_commit)
execute_service(project, commit_author, @oldrev, @newrev, @ref )
end
it "doesn't create additional cross-reference notes" do
expect(SystemNoteService).not_to receive(:cross_reference)
execute_service(project, commit_author, @oldrev, @newrev, @ref )
end
it "doesn't close issues when external issue tracker is in use" do
allow_any_instance_of(Project).to receive(:default_issues_tracker?).
and_return(false)
external_issue_tracker = double(title: 'My Tracker', issue_path: issue.iid, reference_pattern: project.issue_reference_pattern)
allow_any_instance_of(Project).to receive(:external_issue_tracker).and_return(external_issue_tracker)
# The push still shouldn't create cross-reference notes.
expect do
execute_service(project, commit_author, @oldrev, @newrev, 'refs/heads/hurf' )
end.not_to change { Note.where(project_id: project.id, system: true).count }
end
end
context "to non-default branches" do
before do
# Make sure the "default" branch is different
allow(project).to receive(:default_branch).and_return('not-master')
end
it "creates cross-reference notes" do
expect(SystemNoteService).to receive(:cross_reference).with(issue, closing_commit, commit_author)
execute_service(project, user, @oldrev, @newrev, @ref )
end
it "doesn't close issues" do
execute_service(project, user, @oldrev, @newrev, @ref )
expect(Issue.find(issue.id)).to be_opened
end
end
context "for jira issue tracker" do
include JiraServiceHelper
let(:jira_tracker) { project.create_jira_service if project.jira_service.nil? }
before do
# project.create_jira_service doesn't seem to invalidate the cache here
project.has_external_issue_tracker = true
jira_service_settings
stub_jira_urls("JIRA-1")
allow(closing_commit).to receive_messages({
issue_closing_regex: Regexp.new(Gitlab.config.gitlab.issue_closing_pattern),
safe_message: message,
author_name: commit_author.name,
author_email: commit_author.email
})
allow(project.repository).to receive_messages(commits_between: [closing_commit])
end
after do
jira_tracker.destroy!
end
context "mentioning an issue" do
let(:message) { "this is some work.\n\nrelated to JIRA-1" }
it "initiates one api call to jira server to mention the issue" do
execute_service(project, user, @oldrev, @newrev, @ref)
expect(WebMock).to have_requested(:post, jira_api_comment_url('JIRA-1')).with(
body: /mentioned this issue in/
).once
end
end
context "closing an issue" do
let(:message) { "this is some work.\n\ncloses JIRA-1" }
let(:comment_body) { { body: "Issue solved with [#{closing_commit.id}|http://#{Gitlab.config.gitlab.host}/#{project.path_with_namespace}/commit/#{closing_commit.id}]." }.to_json }
before do
open_issue = JIRA::Resource::Issue.new(jira_tracker.client, attrs: { "id" => "JIRA-1" })
closed_issue = open_issue.dup
allow(open_issue).to receive(:resolution).and_return(false)
allow(closed_issue).to receive(:resolution).and_return(true)
allow(JIRA::Resource::Issue).to receive(:find).and_return(open_issue, closed_issue)
allow_any_instance_of(JIRA::Resource::Issue).to receive(:key).and_return("JIRA-1")
end
context "using right markdown" do
it "initiates one api call to jira server to close the issue" do
execute_service(project, commit_author, @oldrev, @newrev, @ref )
expect(WebMock).to have_requested(:post, jira_api_transition_url('JIRA-1')).once
end
it "initiates one api call to jira server to comment on the issue" do
execute_service(project, commit_author, @oldrev, @newrev, @ref )
expect(WebMock).to have_requested(:post, jira_api_comment_url('JIRA-1')).with(
body: comment_body
).once
end
end
context "using wrong markdown" do
let(:message) { "this is some work.\n\ncloses #1" }
it "does not initiates one api call to jira server to close the issue" do
execute_service(project, commit_author, @oldrev, @newrev, @ref )
expect(WebMock).not_to have_requested(:post, jira_api_transition_url('JIRA-1'))
end
it "does not initiates one api call to jira server to comment on the issue" do
execute_service(project, commit_author, @oldrev, @newrev, @ref )
expect(WebMock).not_to have_requested(:post, jira_api_comment_url('JIRA-1')).with(
body: comment_body
).once
end
end
end
end
end
describe "empty project" do
let(:project) { create(:project_empty_repo) }
let(:new_ref) { 'refs/heads/feature'}
before do
allow(project).to receive(:default_branch).and_return('feature')
expect(project).to receive(:change_head) { 'feature'}
end
it 'push to first branch updates HEAD' do
execute_service(project, user, @blankrev, @newrev, new_ref )
end
end
describe "housekeeping" do
let(:housekeeping) { Projects::HousekeepingService.new(project) }
before do
# Flush any raw Redis data stored by the housekeeping code.
Gitlab::Redis.with { |conn| conn.flushall }
allow(Projects::HousekeepingService).to receive(:new).and_return(housekeeping)
end
after do
Gitlab::Redis.with { |conn| conn.flushall }
end
it 'does not perform housekeeping when not needed' do
expect(housekeeping).not_to receive(:execute)
execute_service(project, user, @oldrev, @newrev, @ref)
end
context 'when housekeeping is needed' do
before do
allow(housekeeping).to receive(:needed?).and_return(true)
end
it 'performs housekeeping' do
expect(housekeeping).to receive(:execute)
execute_service(project, user, @oldrev, @newrev, @ref)
end
it 'does not raise an exception' do
allow(housekeeping).to receive(:try_obtain_lease).and_return(false)
execute_service(project, user, @oldrev, @newrev, @ref)
end
end
it 'increments the push counter' do
expect(housekeeping).to receive(:increment!)
execute_service(project, user, @oldrev, @newrev, @ref)
end
end
describe '#update_caches' do
let(:service) do
described_class.new(project,
user,
oldrev: sample_commit.parent_id,
newrev: sample_commit.id,
ref: 'refs/heads/master')
end
context 'on the default branch' do
before do
allow(service).to receive(:is_default_branch?).and_return(true)
end
it 'flushes the caches of any special files that have been changed' do
commit = double(:commit)
diff = double(:diff, new_path: 'README.md')
expect(commit).to receive(:raw_diffs).with(deltas_only: true).
and_return([diff])
service.push_commits = [commit]
expect(ProjectCacheWorker).to receive(:perform_async).
with(project.id, %i(readme), %i(commit_count repository_size))
service.update_caches
end
end
context 'on a non-default branch' do
before do
allow(service).to receive(:is_default_branch?).and_return(false)
end
it 'does not flush any conditional caches' do
expect(ProjectCacheWorker).to receive(:perform_async).
with(project.id, [], %i(commit_count repository_size)).
and_call_original
service.update_caches
end
end
end
describe '#process_commit_messages' do
let(:service) do
described_class.new(project,
user,
oldrev: sample_commit.parent_id,
newrev: sample_commit.id,
ref: 'refs/heads/master')
end
it 'only schedules a limited number of commits' do
allow(service).to receive(:push_commits).
and_return(Array.new(1000, double(:commit, to_hash: {})))
expect(ProcessCommitWorker).to receive(:perform_async).exactly(100).times
service.process_commit_messages
end
end
def execute_service(project, user, oldrev, newrev, ref)
service = described_class.new(project, user, oldrev: oldrev, newrev: newrev, ref: ref )
service.execute
service
end
end
| 35.346908 | 190 | 0.66422 |
1cf5f9404cb10af8dc3ba655a33fc4f661279a43 | 4,516 | require 'spec_helper'
# Suppose the following class exists:
#
# class User < ActiveRecord::Base
# include Friendable::UserMethods
# end
describe Friendable::UserMethods do
def redis; Friendable.redis; end
before(:each) { redis.flushdb }
let(:current_user) { User.first }
let(:target_user) { User.last }
subject { current_user }
its(:friend_list_key) { should == "Users:friend_list:1" }
describe "#friend!" do
context "to add a friend" do
before { current_user.friend!(target_user) }
specify { current_user.friend?(target_user).should be_true }
specify { redis.hkeys(current_user.friend_list_key).should include(target_user.id.to_s) }
specify { redis.hkeys(target_user.friend_list_key).should include(current_user.id.to_s) }
end
context "to add a friend with several options" do
let(:friendship) { current_user.friend!(target_user, :foo => "bar", :hoge => "fuga") }
subject { friendship }
it { should be_a(Friendable::Friendship) }
its(:friend){ should == target_user }
its(:foo){ should == "bar" }
its(:hoge){ should == "fuga" }
end
context "to add a friend without options" do
let(:friendship) { current_user.friend!(target_user) }
subject { friendship }
it { should be_a(Friendable::Friendship) }
its(:friend){ should == target_user }
end
end
describe "#unfriend!" do
context "to remove a friendship" do
before do
current_user.friend!(target_user)
current_user.unfriend!(target_user)
end
specify { current_user.friend?(target_user).should be_false }
specify { redis.hexists(current_user.friend_list_key, target_user.id.to_s).should be_false }
specify { redis.hexists(target_user.friend_list_key, current_user.id.to_s).should be_false }
end
end
describe "#friends" do
subject { current_user.friends }
context "without friends" do
it { should be_an(ActiveRecord::Relation) }
its(:count){ should == 0 }
end
context "with one friend" do
before { current_user.friend!(target_user) }
it { should include(target_user) }
end
end
describe "#friendships" do
subject { current_user.friendships }
context "without friends to return an empty erray" do
it { should be_an(Array) }
its(:count) { should == 0 }
end
context "with one friend to return an array of friendship objects" do
before { current_user.friend!(target_user, :foo => "bar", :hoge => "fuga") }
subject { current_user.friendships.first }
it { should be_a(Friendable::Friendship) }
its(:source_resource) { should == current_user }
its(:target_resource) { should == target_user }
its(:created_at) { should be_a(ActiveSupport::TimeWithZone) }
its(:updated_at) { should be_a(ActiveSupport::TimeWithZone) }
its(:foo) { should == "bar" }
its(:hoge) { should == "fuga" }
end
end
describe "#friendship_with" do
context "without friends" do
specify do
expect {
current_user.friendship_with(target_user)
}.to raise_exception(Friendable::FriendshipNotFound)
end
end
context "with one friend" do
before { current_user.friend!(target_user, :foo => "bar", :hoge => "fuga") }
subject { current_user.friendship_with(target_user) }
it { should be_a(Friendable::Friendship) }
its(:foo) { should == "bar" }
its(:hoge) { should == "fuga" }
end
end
describe "#friend_ids" do
subject { current_user.friend_ids }
context "without friends" do
it { should be_an(Array) }
its(:count) { should == 0 }
end
context "with one friend" do
before { current_user.friend!(target_user) }
it { should include(target_user.id) }
end
context "without friends after unfriend" do
before do
current_user.friend!(target_user)
current_user.unfriend!(target_user)
end
it { should_not include(target_user.id) }
end
end
describe "#friends_count" do
subject { current_user.friends_count }
context "without friends" do
it { should == 0 }
end
context "with one friend" do
before { current_user.friend!(target_user) }
it { should == 1 }
end
context "without friends after unfriend" do
before do
current_user.friend!(target_user)
current_user.unfriend!(target_user)
end
it { should == 0 }
end
end
end
| 29.324675 | 98 | 0.64814 |
ff9ff58f814b1a2eea8f5f34bd4a498aa5e95fad | 2,645 |
RSpec.shared_context "nucleon_codes" do
#*****************************************************************************
# Code initialization
let(:codes_registry_clean) do {
:success => 0,
:help_wanted => 1,
:unknown_status => 2,
:action_unprocessed => 3,
:batch_error => 4,
:validation_failed => 5,
:access_denied => 6
}
end
let(:codes_status_index_clean) do {
0 => "success",
1 => "help_wanted",
2 => "unknown_status",
3 => "action_unprocessed",
4 => "batch_error",
5 => "validation_failed",
6 => "access_denied"
}
end
let(:codes_registry_custom) do {
:success => 0,
:help_wanted => 1,
:unknown_status => 2,
:action_unprocessed => 3,
:batch_error => 4,
:validation_failed => 5,
:access_denied => 6,
:good => 7,
:bad => 8,
:ok => 9,
:wow => 10,
:whew => 11
}
end
let(:codes_status_index_custom) do {
0 => "success",
1 => "help_wanted",
2 => "unknown_status",
3 => "action_unprocessed",
4 => "batch_error",
5 => "validation_failed",
6 => "access_denied",
7 => "good",
8 => "bad",
9 => "ok",
10 => "wow",
11 => "whew"
}
end
before(:each) do
# Set custom codes before every test
Nucleon::Codes.reset # 0 - 6 reserved
Nucleon::Codes.codes(:good, :bad, :ok, :wow, :whew) # 7 - ?
end
#*****************************************************************************
# Code test utilities
def codes_rendered_status(status_code = nil)
# Basically copied from the Codes class to ensure parity over time.
if ! status_code.nil? && codes_status_index_custom.has_key?(status_code)
status_name = codes_status_index_custom[status_code]
else
status_name = codes_status_index_custom[codes_registry_custom[:unknown_status]]
end
sprintf(" [ %3i ] - %s\n", status_code, status_name.gsub(/_/, ' ').capitalize)
end
def codes_rendered_index(status_code = nil)
# Basically copied from the Codes class to ensure parity over time.
output = "Status index:\n"
codes_status_index_custom.each do |code, name|
name = name.gsub(/_/, ' ').capitalize
if ! status_code.nil? && status_code == code
output << sprintf(" [ %3i ] - %s\n", code, name)
else
output << sprintf(" %3i - %s\n", code, name)
end
end
output << "\n"
output
end
end | 26.989796 | 85 | 0.507372 |
1df46a3fd2f83abdd5483ec111e4d6fac9795a24 | 1,384 | # Wraps up logic for querying the IAL level of an authorization request
class IalContext
attr_reader :ial, :service_provider
# @param ial [String, Integer] IAL level as either an integer (see ::Idp::Constants::IAL2, etc)
# or a string see Saml::Idp::Constants contexts
# @param service_provider [ServiceProvider, nil]
def initialize(ial:, service_provider:)
@ial = int_ial(ial)
@service_provider = service_provider
end
def ial2_service_provider?
service_provider.ial.to_i >= ::Idp::Constants::IAL2
end
def ialmax_requested?
ial&.zero?
end
def ial2_requested?
ial == ::Idp::Constants::IAL2
end
def ial2_or_greater?
ial2_requested? || ial2_strict_requested?
end
def ial2_strict_requested?
ial == ::Idp::Constants::IAL2_STRICT ||
(ial == ::Idp::Constants::IAL2 && service_provider_requires_liveness?)
end
def ial_for_identity_record
return ial unless ial == ::Idp::Constants::IAL2 && service_provider_requires_liveness?
::Idp::Constants::IAL2_STRICT
end
private
def service_provider_requires_liveness?
!!service_provider && service_provider.liveness_checking_required
end
def int_ial(input)
Integer(input)
rescue TypeError # input was nil
nil
rescue ArgumentError # input was probably a string
Saml::Idp::Constants::AUTHN_CONTEXT_CLASSREF_TO_IAL.fetch(input)
end
end
| 26.113208 | 97 | 0.726879 |
0184ddfbeffaece936f1c158adab4d80f93c86f2 | 9,109 | require 'test_helper'
class MetricsGlobalTest < Test::Unit::TestCase
include CommStub
def setup
@gateway = ActiveMerchant::Billing::MetricsGlobalGateway.new(
:login => 'X',
:password => 'Y'
)
@amount = 100
@credit_card = credit_card('4111111111111111', :verification_value => '999')
@subscription_id = '100748'
@subscription_status = 'active'
end
def test_successful_authorization
@gateway.expects(:ssl_post).returns(successful_authorization_response)
assert response = @gateway.authorize(@amount, @credit_card)
assert_instance_of Response, response
assert_success response
assert_equal '508141794', response.authorization
end
def test_successful_purchase
@gateway.expects(:ssl_post).returns(successful_purchase_response)
assert response = @gateway.purchase(@amount, @credit_card)
assert_instance_of Response, response
assert_success response
assert_equal '508141795', response.authorization
end
def test_failed_authorization
@gateway.expects(:ssl_post).returns(failed_authorization_response)
assert response = @gateway.authorize(@amount, @credit_card)
assert_instance_of Response, response
assert_failure response
assert_equal '508141794', response.authorization
end
def test_add_address_outsite_north_america
result = {}
@gateway.send(:add_address, result, :billing_address => {:address1 => '164 Waverley Street', :country => 'DE', :state => ''})
assert_equal ['address', 'city', 'company', 'country', 'phone', 'state', 'zip'], result.stringify_keys.keys.sort
assert_equal 'n/a', result[:state]
assert_equal '164 Waverley Street', result[:address]
assert_equal 'DE', result[:country]
end
def test_add_address
result = {}
@gateway.send(:add_address, result, :billing_address => {:address1 => '164 Waverley Street', :country => 'US', :state => 'CO'})
assert_equal ['address', 'city', 'company', 'country', 'phone', 'state', 'zip'], result.stringify_keys.keys.sort
assert_equal 'CO', result[:state]
assert_equal '164 Waverley Street', result[:address]
assert_equal 'US', result[:country]
end
def test_add_invoice
result = {}
@gateway.send(:add_invoice, result, :order_id => '#1001')
assert_equal '#1001', result[:invoice_num]
end
def test_add_description
result = {}
@gateway.send(:add_invoice, result, :description => 'My Purchase is great')
assert_equal 'My Purchase is great', result[:description]
end
def test_add_duplicate_window_without_duplicate_window
result = {}
@gateway.class.duplicate_window = nil
@gateway.send(:add_duplicate_window, result)
assert_nil result[:duplicate_window]
end
def test_add_duplicate_window_with_duplicate_window
result = {}
@gateway.class.duplicate_window = 0
@gateway.send(:add_duplicate_window, result)
assert_equal 0, result[:duplicate_window]
end
def test_purchase_is_valid_csv
params = { :amount => '1.01' }
@gateway.send(:add_creditcard, params, @credit_card)
assert data = @gateway.send(:post_data, 'AUTH_ONLY', params)
assert_equal post_data_fixture.size, data.size
end
def test_purchase_meets_minimum_requirements
params = {
:amount => '1.01',
}
@gateway.send(:add_creditcard, params, @credit_card)
assert data = @gateway.send(:post_data, 'AUTH_ONLY', params)
minimum_requirements.each do |key|
assert_not_nil(data =~ /x_#{key}=/)
end
end
def test_successful_refund
@gateway.expects(:ssl_post).returns(successful_purchase_response)
assert response = @gateway.refund(@amount, '123456789', :card_number => @credit_card.number)
assert_success response
assert_equal 'This transaction has been approved', response.message
end
def test_refund_passing_extra_info
response = stub_comms do
@gateway.refund(50, '123456789', :card_number => @credit_card.number, :first_name => 'Bob', :last_name => 'Smith', :zip => '12345')
end.check_request do |endpoint, data, headers|
assert_match(/x_first_name=Bob/, data)
assert_match(/x_last_name=Smith/, data)
assert_match(/x_zip=12345/, data)
end.respond_with(successful_purchase_response)
assert_success response
end
def test_failed_refund
@gateway.expects(:ssl_post).returns(failed_refund_response)
assert response = @gateway.refund(@amount, '123456789', :card_number => @credit_card.number)
assert_failure response
assert_equal 'The referenced transaction does not meet the criteria for issuing a credit', response.message
end
def test_deprecated_credit
@gateway.expects(:ssl_post).returns(successful_purchase_response)
assert_deprecation_warning(Gateway::CREDIT_DEPRECATION_MESSAGE) do
assert response = @gateway.credit(@amount, '123456789', :card_number => @credit_card.number)
assert_success response
assert_equal 'This transaction has been approved', response.message
end
end
def test_supported_countries
assert_equal ['US'], MetricsGlobalGateway.supported_countries
end
def test_supported_card_types
assert_equal [:visa, :master, :american_express, :discover, :diners_club, :jcb], MetricsGlobalGateway.supported_cardtypes
end
def test_failure_without_response_reason_text
assert_nothing_raised do
assert_equal '', @gateway.send(:message_from, {})
end
end
def test_response_under_review_by_fraud_service
@gateway.expects(:ssl_post).returns(fraud_review_response)
response = @gateway.purchase(@amount, @credit_card)
assert_failure response
assert response.fraud_review?
assert_equal 'Thank you! For security reasons your order is currently being reviewed', response.message
end
def test_avs_result
@gateway.expects(:ssl_post).returns(fraud_review_response)
response = @gateway.purchase(@amount, @credit_card)
assert_equal 'X', response.avs_result['code']
end
def test_cvv_result
@gateway.expects(:ssl_post).returns(fraud_review_response)
response = @gateway.purchase(@amount, @credit_card)
assert_equal 'M', response.cvv_result['code']
end
def test_message_from
@gateway.class_eval {
public :message_from
}
result = {
:response_code => 2,
:card_code => 'N',
:avs_result_code => 'A',
:response_reason_code => '27',
:response_reason_text => 'Failure.',
}
assert_equal 'CVV does not match', @gateway.message_from(result)
result[:card_code] = 'M'
assert_equal 'Street address matches, but 5-digit and 9-digit postal code do not match.', @gateway.message_from(result)
result[:response_reason_code] = '22'
assert_equal 'Failure', @gateway.message_from(result)
end
private
def post_data_fixture
'x_encap_char=%24&x_card_num=4242424242424242&x_exp_date=0806&x_card_code=123&x_type=AUTH_ONLY&x_first_name=Longbob&x_version=3.1&x_login=X&x_last_name=Longsen&x_tran_key=Y&x_relay_response=FALSE&x_delim_data=TRUE&x_delim_char=%2C&x_amount=1.01'
end
def minimum_requirements
%w(version delim_data relay_response login tran_key amount card_num exp_date type)
end
def failed_refund_response
'$3$,$2$,$54$,$The referenced transaction does not meet the criteria for issuing a credit.$,$$,$P$,$0$,$$,$$,$1.00$,$CC$,$credit$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$39265D8BA0CDD4F045B5F4129B2AAA01$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$'
end
def successful_authorization_response
'$1$,$1$,$1$,$This transaction has been approved.$,$advE7f$,$Y$,$508141794$,$5b3fe66005f3da0ebe51$,$$,$1.00$,$CC$,$auth_only$,$$,$Longbob$,$Longsen$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$2860A297E0FE804BCB9EF8738599645C$,$P$,$2$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$'
end
def successful_purchase_response
'$1$,$1$,$1$,$This transaction has been approved.$,$d1GENk$,$Y$,$508141795$,$32968c18334f16525227$,$Store purchase$,$1.00$,$CC$,$auth_capture$,$$,$Longbob$,$Longsen$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$269862C030129C1173727CC10B1935ED$,$P$,$2$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$'
end
def failed_authorization_response
'$2$,$1$,$1$,$This transaction was declined.$,$advE7f$,$Y$,$508141794$,$5b3fe66005f3da0ebe51$,$$,$1.00$,$CC$,$auth_only$,$$,$Longbob$,$Longsen$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$2860A297E0FE804BCB9EF8738599645C$,$P$,$2$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$'
end
def fraud_review_response
'$4$,$$,$253$,$Thank you! For security reasons your order is currently being reviewed.$,$$,$X$,$0$,$$,$$,$1.00$,$$,$auth_capture$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$207BCBBF78E85CF174C87AE286B472D2$,$M$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$,$$'
end
end
| 38.597458 | 363 | 0.661324 |
399f5f3c362e80ba56baaafd9df2b57b8035f1d9 | 952 | class ENV_BANG
module Classes
class << self
attr_writer :default_class
def default_class
@default_class ||= :StringUnlessFalsey
end
def cast(value, options = {})
public_send(:"#{options.fetch(:class, default_class)}", value, options)
end
def boolean(value, options)
!(value =~ /^(|0|disabled?|false|no|off)$/i)
end
def Array(value, options)
item_options = options.merge(class: options.fetch(:of, default_class))
value.split(',').map { |value| cast(value.strip, item_options) }
end
def Symbol(value, options)
value.to_sym
end
def StringUnlessFalsey(value, options)
boolean(value, options) && value
end
# Delegate methods like Integer(), Float(), String(), etc. to the Kernel module
def method_missing(klass, value, options, &block)
Kernel.send(klass, value)
end
end
end
end
| 25.052632 | 85 | 0.609244 |
e9a29e75358ec058ca30fcbfb8e2e1b3f1c3f061 | 728 | class AssignmentFilesController < ApplicationController
before_action :set_current_course
before_action :authenticated_as_user
# GET /6.006/assignment_files/1/download
def download
@file = AssignmentFile.find params[:id]
return bounce_user unless @file.can_read? current_user
db_file = @file.db_file
# NOTE: The CSP header provides some protection against an attacker who
# tries to serve active content (HTML+JS) using the server's origin.
# DbFile also explicitly disallows the HTML and XHTML MIME types.
response.headers['Content-Security-Policy'] = "default-src 'none'"
send_data @file.contents, filename: @file.file_name,
type: db_file.f.content_type
end
end
| 38.315789 | 78 | 0.740385 |
e986ffa00ce63e4540ac1bad0bbd5ed28ff29ca4 | 2,325 | module ActiveNotifier
class Base
attr_accessor :recipient, :channels
def initialize(attributes={})
attributes.each do |(key, value)|
self.public_send("#{key}=", value)
end
end
delegate :deliver_now, to: :deliverable
def deliver_now
delivered = false
locale = self.class.locale_for(recipient)
I18n.with_locale(locale) do
until channels.empty? || delivered
channel = channels.shift
begin
deliverable(channel).deliver_now
delivered = true
rescue ActiveNotifier::DeliveryImpossible => e
delivered = false
msg = "Unable to deliver to channel #{channel}"
ActiveNotifier.logger && ActiveNotifier.logger.warn(msg)
end
end
end
end
class << self
attr_accessor :configurations, :locale_attribute
def deliver_now(attributes)
new(attributes).deliver_now
end
def deliver_through(channel, &blk)
self.configurations ||= {}
config = Configuration.new.tap(&blk)
configurations[channel] = config
end
def locale_for(recipient)
recipient.public_send(locale_attribute)
rescue
I18n.default_locale
end
end
private
def deliverable(channel)
configuration = self.class.configurations[channel]
transport = ActiveNotifier::Transports.for(channel, configuration, self)
transport.deliverable(self)
end
class Configuration
attr_accessor :data
def initialize
@data = {
from: nil,
email_attribute: nil,
subject: nil,
superclass: ActionMailer::Base
}
end
delegate :[], to: :data
def method_missing(*args, &blk)
attribute, value = args
if value.present?
@data[attribute] = value
elsif block_given?
@data[attribute] = blk
else
@data.fetch attribute do
super
end
end
end
def respond_to?(*args, &blk)
attribute, value = args
if value.present?
true
elsif block_given?
true
else
@data.fetch attribute do
super
end
end
end
end
end
end
| 23.019802 | 78 | 0.577204 |
6aaf25e072563b7bfe88fb877d09ab56ab1fd2d6 | 2,677 | Pod::Spec.new do |s|
s.name = "Nimble"
s.version = "7.1.2"
s.summary = "A Matcher Framework for Swift and Objective-C"
s.description = <<-DESC
Use Nimble to express the expected outcomes of Swift or Objective-C expressions. Inspired by Cedar.
DESC
s.homepage = "https://github.com/Quick/Nimble"
s.license = { :type => "Apache 2.0", :file => "LICENSE" }
s.author = "Quick Contributors"
s.ios.deployment_target = "8.0"
s.osx.deployment_target = "10.10"
s.tvos.deployment_target = "9.0"
s.source = { :git => "https://github.com/Quick/Nimble.git",
:tag => "v#{s.version}" }
s.source_files = [
"Sources/**/*.{swift,h,m,c}",
"Carthage/Checkouts/CwlCatchException/Sources/**/*.{swift,h,m,c}",
"Carthage/Checkouts/CwlPreconditionTesting/Sources/**/*.{swift,h,m,c}",
]
s.osx.exclude_files = [
"Carthage/Checkouts/CwlPreconditionTesting/Sources/CwlPreconditionTesting/CwlCatchBadInstructionPosix.swift",
"Carthage/Checkouts/CwlPreconditionTesting/Sources/CwlPreconditionTesting/Posix/CwlPreconditionTesting_POSIX.h",
]
s.ios.exclude_files = [
"Carthage/Checkouts/CwlPreconditionTesting/Sources/CwlPreconditionTesting/CwlCatchBadInstructionPosix.swift",
"Carthage/Checkouts/CwlPreconditionTesting/Sources/CwlPreconditionTesting/Posix/CwlPreconditionTesting_POSIX.h",
]
s.tvos.exclude_files = [
"Carthage/Checkouts/CwlPreconditionTesting/Sources/CwlPreconditionTesting/Mach/CwlPreconditionTesting.h",
"Carthage/Checkouts/CwlPreconditionTesting/Sources/CwlPreconditionTesting/CwlCatchBadInstruction.swift",
"Carthage/Checkouts/CwlPreconditionTesting/Sources/CwlPreconditionTesting/CwlBadInstructionException.swift",
"Carthage/Checkouts/CwlPreconditionTesting/Sources/CwlPreconditionTesting/CwlDarwinDefinitions.swift",
"Carthage/Checkouts/CwlCatchException/Sources/CwlCatchException/CwlCatchException.swift",
"Carthage/Checkouts/CwlCatchException/Sources/CwlCatchExceptionSupport/CwlCatchException.m",
"Carthage/Checkouts/CwlCatchException/Sources/CwlCatchExceptionSupport/include/CwlCatchException.h",
]
s.exclude_files = "Sources/Nimble/Adapters/NonObjectiveC/*.swift"
s.weak_framework = "XCTest"
s.requires_arc = true
s.compiler_flags = '-DPRODUCT_NAME=Nimble/Nimble'
s.pod_target_xcconfig = {
'APPLICATION_EXTENSION_API_ONLY' => 'YES',
'ENABLE_BITCODE' => 'NO',
'OTHER_LDFLAGS' => '-weak-lswiftXCTest',
'OTHER_SWIFT_FLAGS' => '$(inherited) -suppress-warnings',
'FRAMEWORK_SEARCH_PATHS' => '$(inherited) "$(PLATFORM_DIR)/Developer/Library/Frameworks"',
}
end
| 50.509434 | 118 | 0.731789 |
b9467748793d6ff28960fbfc9971cde0982ffc13 | 239 | module ScorchedBlog
class BaseController < Scorched::Controller
render_defaults[:layout] = File.expand_path('../templates/layout.erb', __FILE__).to_sym
render_defaults[:dir] = File.expand_path('../templates', __FILE__)
end
end
| 34.142857 | 91 | 0.748954 |
ab094426054377a1c825441b0793d8b4f22fc85a | 8,488 | require "spec_helper"
module Berkshelf
describe Downloader do
let(:berksfile) do
double(Berksfile,
lockfile: lockfile,
dependencies: [])
end
let(:lockfile) do
double(Lockfile,
graph: graph)
end
let(:graph) { double(Lockfile::Graph, locks: {}) }
let(:self_signed_crt_path) { File.join(BERKS_SPEC_DATA, "trusted_certs") }
let(:self_signed_crt) { OpenSSL::X509::Certificate.new(IO.read("#{self_signed_crt_path}/example.crt")) }
let(:cert_store) { OpenSSL::X509::Store.new.add_cert(self_signed_crt) }
let(:ssl_policy) { double(SSLPolicy, store: cert_store) }
subject { described_class.new(berksfile) }
describe "#download" do
skip
end
describe "#try_download" do
let(:remote_cookbook) { double("remote-cookbook") }
let(:source) do
source = double("source")
allow(source).to receive(:cookbook) { remote_cookbook }
source
end
let(:name) { "fake" }
let(:version) { "1.0.0" }
it "supports the 'opscode' location type" do
allow(source).to receive(:type) { :supermarket }
allow(source).to receive(:options) { { ssl: {} } }
allow(remote_cookbook).to receive(:location_type) { :opscode }
allow(remote_cookbook).to receive(:location_path) { "http://api.opscode.com" }
rest = double("community-rest")
expect(CommunityREST).to receive(:new).with("http://api.opscode.com", { ssl: {} }) { rest }
expect(rest).to receive(:download).with(name, version)
subject.try_download(source, name, version)
end
it "supports the 'supermarket' location type" do
allow(source).to receive(:type) { :supermarket }
allow(source).to receive(:options) { { ssl: {} } }
allow(remote_cookbook).to receive(:location_type) { :supermarket }
allow(remote_cookbook).to receive(:location_path) { "http://api.supermarket.com" }
rest = double("community-rest")
expect(CommunityREST).to receive(:new).with("http://api.supermarket.com", { ssl: {} }) { rest }
expect(rest).to receive(:download).with(name, version)
subject.try_download(source, name, version)
end
context "supports location paths" do
before(:each) do
allow(source).to receive(:type) { :supermarket }
allow(source).to receive(:options) { { ssl: {} } }
allow(source).to receive(:uri_string).and_return("http://localhost:8081/repository/chef-proxy")
allow(remote_cookbook).to receive(:location_type) { :opscode }
end
let(:rest) { double("community-rest") }
it "that are relative and prepends the source URI for the download" do
allow(remote_cookbook).to receive(:location_path) { "/api/v1" }
expect(CommunityREST).to receive(:new).with("http://localhost:8081/repository/chef-proxy/api/v1", { ssl: {} }) { rest }
expect(rest).to receive(:download).with(name, version)
subject.try_download(source, name, version)
end
it "that are absolute and uses the given absolute URI" do
allow(remote_cookbook).to receive(:location_path) { "http://localhost:8081/repository/chef-proxy/api/v1" }
expect(CommunityREST).to receive(:new).with("http://localhost:8081/repository/chef-proxy/api/v1", { ssl: {} }) { rest }
expect(rest).to receive(:download).with(name, version)
subject.try_download(source, name, version)
end
end
context "with an artifactory source" do
it "supports the 'opscode' location type" do
allow(source).to receive(:type) { :artifactory }
allow(source).to receive(:options) { { api_key: "secret", ssl: {} } }
allow(remote_cookbook).to receive(:location_type) { :opscode }
allow(remote_cookbook).to receive(:location_path) { "http://artifactory/" }
rest = double("community-rest")
expect(CommunityREST).to receive(:new).with("http://artifactory/", { ssl: {}, headers: { "X-Jfrog-Art-Api" => "secret" } }) { rest }
expect(rest).to receive(:download).with(name, version)
subject.try_download(source, name, version)
end
it "supports the 'supermarket' location type" do
allow(source).to receive(:type) { :artifactory }
allow(source).to receive(:options) { { api_key: "secret", ssl: {} } }
allow(remote_cookbook).to receive(:location_type) { :supermarket }
allow(remote_cookbook).to receive(:location_path) { "http://artifactory/" }
rest = double("community-rest")
expect(CommunityREST).to receive(:new).with("http://artifactory/", { ssl: {}, headers: { "X-Jfrog-Art-Api" => "secret" } }) { rest }
expect(rest).to receive(:download).with(name, version)
subject.try_download(source, name, version)
end
end
describe "chef_server location type" do
let(:chef_server_url) { "http://configured-chef-server/" }
let(:ridley_client) do
instance_double(Berkshelf::RidleyCompat)
end
let(:chef_config) do
double(Berkshelf::ChefConfigCompat,
node_name: "fake-client",
client_key: "client-key",
chef_server_url: chef_server_url,
validation_client_name: "validator",
validation_key: "validator.pem",
artifactory_api_key: "secret",
cookbook_copyright: "user",
cookbook_email: "[email protected]",
cookbook_license: "apachev2",
trusted_certs_dir: self_signed_crt_path)
end
let(:berkshelf_config) do
double(Config,
ssl: double(verify: true),
chef: chef_config)
end
before do
allow(Berkshelf).to receive(:config).and_return(berkshelf_config)
allow(subject).to receive(:ssl_policy).and_return(ssl_policy)
allow(remote_cookbook).to receive(:location_type) { :chef_server }
allow(remote_cookbook).to receive(:location_path) { chef_server_url }
allow(source).to receive(:options) { { read_timeout: 30, open_timeout: 3, ssl: { verify: true, cert_store: cert_store } } }
end
it "uses the berkshelf config and provides a custom cert_store" do
credentials = {
server_url: chef_server_url,
client_name: chef_config.node_name,
client_key: chef_config.client_key,
ssl: {
verify: berkshelf_config.ssl.verify,
cert_store: cert_store,
},
}
expect(Berkshelf::RidleyCompat).to receive(:new_client).with(credentials) { ridley_client }
subject.try_download(source, name, version)
end
context "with a source option for client_name" do
before do
allow(source).to receive(:options) { { client_name: "other-client", read_timeout: 30, open_timeout: 3, ssl: { verify: true, cert_store: cert_store } } }
end
it "uses the override" do
credentials = {
server_url: chef_server_url,
client_name: "other-client",
client_key: chef_config.client_key,
ssl: {
verify: berkshelf_config.ssl.verify,
cert_store: cert_store,
},
}
expect(Berkshelf::RidleyCompat).to receive(:new_client).with(credentials) { ridley_client }
subject.try_download(source, name, version)
end
end
context "with a source option for client_key" do
before do
allow(source).to receive(:options) { { client_key: "other-key", read_timeout: 30, open_timeout: 3, ssl: { verify: true, cert_store: cert_store } } }
end
it "uses the override" do
credentials = {
server_url: chef_server_url,
client_name: chef_config.node_name,
client_key: "other-key",
ssl: {
verify: berkshelf_config.ssl.verify,
cert_store: cert_store,
},
}
expect(Berkshelf::RidleyCompat).to receive(:new_client).with(credentials) { ridley_client }
subject.try_download(source, name, version)
end
end
end
it "supports the 'file_store' location type" do
skip
end
end
end
end
| 42.228856 | 164 | 0.606032 |
ed4205a477eb5df54f345873853a2d70a34910b5 | 104 | class HomeController < ApplicationController
def index
end
def contact_us
end
end
| 9.454545 | 44 | 0.673077 |
1ae7cba70393d7c5574397e381d06de5f1a61482 | 302 | package "git-daemon-sysvinit"
directory "/srv/repos" do
recursive true
end
template '/etc/default/git-daemon' do
source 'git-daemon.erb'
owner 'root'
mode '0644'
variables :git_root => '/srv/repos'
end
service "git-daemon" do
provider Chef::Provider::Service::Init
action [:start]
end
| 16.777778 | 40 | 0.708609 |
624d0200f7817d44ea1537254e49d46ef7bb7d99 | 2,610 | require 'spec_helper'
RSpec.describe DeserializationRetry do
context 'when a Delayed::Job fails to load because the class is missing' do
it 'prevents DelayedJob from marking it as failed' do
handler = VCAP::CloudController::Jobs::Runtime::EventsCleanup.new(10_000)
VCAP::CloudController::Jobs::Enqueuer.new(handler).enqueue
job = Delayed::Job.last
job.update handler: job.handler.gsub('EventsCleanup', 'Dan')
Delayed::Worker.new.work_off
job.reload
expect(job.failed_at).to be_nil
expect(job.locked_by).to be_nil
expect(job.locked_at).to be_nil
expect(job.run_at).to be_within(2.seconds).of Delayed::Job.db_time_now + 5.minutes
expect(job.attempts).to eq(1)
end
context 'and we have been retrying for more than 24 hours' do
it 'stops retrying the job' do
handler = VCAP::CloudController::Jobs::Runtime::EventsCleanup.new(10_000)
VCAP::CloudController::Jobs::Enqueuer.new(handler).enqueue
job = Delayed::Job.last
job.update handler: job.handler.gsub('EventsCleanup', 'Dan'), created_at: Delayed::Job.db_time_now - 24.hours - 1.second
Delayed::Worker.new.work_off
expect(job.reload.failed_at).not_to be_nil
end
end
end
context 'when a Delayed::Job fails to load because of another reason' do
it 'allows the job to be marked as failed' do
handler = VCAP::CloudController::Jobs::Runtime::EventsCleanup.new(10_000)
VCAP::CloudController::Jobs::Enqueuer.new(handler).enqueue
job = Delayed::Job.last
job.update handler: 'Dan'
execute_all_jobs(expected_successes: 0, expected_failures: 1)
expect(job.reload.attempts).to eq(1)
end
end
context 'when the Delayed::Job is well formed' do
it 'executes the job' do
handler = VCAP::CloudController::Jobs::Runtime::EventsCleanup.new(10_000)
VCAP::CloudController::Jobs::Enqueuer.new(handler).enqueue
execute_all_jobs(expected_successes: 1, expected_failures: 0)
end
context 'and the job blows up during execution' do
class BoomJob < VCAP::CloudController::Jobs::CCJob
def perform
raise 'BOOOM!'
end
end
it 'does not retry' do
handler = BoomJob.new
VCAP::CloudController::Jobs::Enqueuer.new(handler).enqueue
job = Delayed::Job.last
old_run_at = job.run_at
execute_all_jobs(expected_successes: 0, expected_failures: 1)
expect(job.reload.run_at).to eq old_run_at
expect(job.reload.failed_at).not_to be_nil
end
end
end
end
| 32.222222 | 128 | 0.681992 |
7ad3a48b0eaa7f034d3f7d558db60510a1b9d733 | 137 | class OrderedPost
include Mongoid::Document
field :title, :type => String
field :rating, :type => Integer
belongs_to :person
end
| 19.571429 | 33 | 0.722628 |
5d5a335acb3df5145683cda329c8e6979efe00d1 | 19,168 | # frozen_string_literal: true
# Copyright 2021 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# Auto-generated by gapic-generator-ruby. DO NOT EDIT!
require "helper"
require "gapic/grpc/service_stub"
require "google/cloud/binaryauthorization/v1beta1/service_pb"
require "google/cloud/binaryauthorization/v1beta1/service_services_pb"
require "google/cloud/binary_authorization/v1beta1/binauthz_management_service"
class ::Google::Cloud::BinaryAuthorization::V1beta1::BinauthzManagementService::ClientTest < Minitest::Test
class ClientStub
attr_accessor :call_rpc_count, :requests
def initialize response, operation, &block
@response = response
@operation = operation
@block = block
@call_rpc_count = 0
@requests = []
end
def call_rpc *args, **kwargs
@call_rpc_count += 1
@requests << @block&.call(*args, **kwargs)
yield @response, @operation if block_given?
@response
end
end
def test_get_policy
# Create GRPC objects.
grpc_response = ::Google::Cloud::BinaryAuthorization::V1beta1::Policy.new
grpc_operation = GRPC::ActiveCall::Operation.new nil
grpc_channel = GRPC::Core::Channel.new "localhost:8888", nil, :this_channel_is_insecure
grpc_options = {}
# Create request parameters for a unary method.
name = "hello world"
get_policy_client_stub = ClientStub.new grpc_response, grpc_operation do |name, request, options:|
assert_equal :get_policy, name
assert_kind_of ::Google::Cloud::BinaryAuthorization::V1beta1::GetPolicyRequest, request
assert_equal "hello world", request["name"]
refute_nil options
end
Gapic::ServiceStub.stub :new, get_policy_client_stub do
# Create client
client = ::Google::Cloud::BinaryAuthorization::V1beta1::BinauthzManagementService::Client.new do |config|
config.credentials = grpc_channel
end
# Use hash object
client.get_policy({ name: name }) do |response, operation|
assert_equal grpc_response, response
assert_equal grpc_operation, operation
end
# Use named arguments
client.get_policy name: name do |response, operation|
assert_equal grpc_response, response
assert_equal grpc_operation, operation
end
# Use protobuf object
client.get_policy ::Google::Cloud::BinaryAuthorization::V1beta1::GetPolicyRequest.new(name: name) do |response, operation|
assert_equal grpc_response, response
assert_equal grpc_operation, operation
end
# Use hash object with options
client.get_policy({ name: name }, grpc_options) do |response, operation|
assert_equal grpc_response, response
assert_equal grpc_operation, operation
end
# Use protobuf object with options
client.get_policy(::Google::Cloud::BinaryAuthorization::V1beta1::GetPolicyRequest.new(name: name), grpc_options) do |response, operation|
assert_equal grpc_response, response
assert_equal grpc_operation, operation
end
# Verify method calls
assert_equal 5, get_policy_client_stub.call_rpc_count
end
end
def test_update_policy
# Create GRPC objects.
grpc_response = ::Google::Cloud::BinaryAuthorization::V1beta1::Policy.new
grpc_operation = GRPC::ActiveCall::Operation.new nil
grpc_channel = GRPC::Core::Channel.new "localhost:8888", nil, :this_channel_is_insecure
grpc_options = {}
# Create request parameters for a unary method.
policy = {}
update_policy_client_stub = ClientStub.new grpc_response, grpc_operation do |name, request, options:|
assert_equal :update_policy, name
assert_kind_of ::Google::Cloud::BinaryAuthorization::V1beta1::UpdatePolicyRequest, request
assert_equal Gapic::Protobuf.coerce({}, to: ::Google::Cloud::BinaryAuthorization::V1beta1::Policy), request["policy"]
refute_nil options
end
Gapic::ServiceStub.stub :new, update_policy_client_stub do
# Create client
client = ::Google::Cloud::BinaryAuthorization::V1beta1::BinauthzManagementService::Client.new do |config|
config.credentials = grpc_channel
end
# Use hash object
client.update_policy({ policy: policy }) do |response, operation|
assert_equal grpc_response, response
assert_equal grpc_operation, operation
end
# Use named arguments
client.update_policy policy: policy do |response, operation|
assert_equal grpc_response, response
assert_equal grpc_operation, operation
end
# Use protobuf object
client.update_policy ::Google::Cloud::BinaryAuthorization::V1beta1::UpdatePolicyRequest.new(policy: policy) do |response, operation|
assert_equal grpc_response, response
assert_equal grpc_operation, operation
end
# Use hash object with options
client.update_policy({ policy: policy }, grpc_options) do |response, operation|
assert_equal grpc_response, response
assert_equal grpc_operation, operation
end
# Use protobuf object with options
client.update_policy(::Google::Cloud::BinaryAuthorization::V1beta1::UpdatePolicyRequest.new(policy: policy), grpc_options) do |response, operation|
assert_equal grpc_response, response
assert_equal grpc_operation, operation
end
# Verify method calls
assert_equal 5, update_policy_client_stub.call_rpc_count
end
end
def test_create_attestor
# Create GRPC objects.
grpc_response = ::Google::Cloud::BinaryAuthorization::V1beta1::Attestor.new
grpc_operation = GRPC::ActiveCall::Operation.new nil
grpc_channel = GRPC::Core::Channel.new "localhost:8888", nil, :this_channel_is_insecure
grpc_options = {}
# Create request parameters for a unary method.
parent = "hello world"
attestor_id = "hello world"
attestor = {}
create_attestor_client_stub = ClientStub.new grpc_response, grpc_operation do |name, request, options:|
assert_equal :create_attestor, name
assert_kind_of ::Google::Cloud::BinaryAuthorization::V1beta1::CreateAttestorRequest, request
assert_equal "hello world", request["parent"]
assert_equal "hello world", request["attestor_id"]
assert_equal Gapic::Protobuf.coerce({}, to: ::Google::Cloud::BinaryAuthorization::V1beta1::Attestor), request["attestor"]
refute_nil options
end
Gapic::ServiceStub.stub :new, create_attestor_client_stub do
# Create client
client = ::Google::Cloud::BinaryAuthorization::V1beta1::BinauthzManagementService::Client.new do |config|
config.credentials = grpc_channel
end
# Use hash object
client.create_attestor({ parent: parent, attestor_id: attestor_id, attestor: attestor }) do |response, operation|
assert_equal grpc_response, response
assert_equal grpc_operation, operation
end
# Use named arguments
client.create_attestor parent: parent, attestor_id: attestor_id, attestor: attestor do |response, operation|
assert_equal grpc_response, response
assert_equal grpc_operation, operation
end
# Use protobuf object
client.create_attestor ::Google::Cloud::BinaryAuthorization::V1beta1::CreateAttestorRequest.new(parent: parent, attestor_id: attestor_id, attestor: attestor) do |response, operation|
assert_equal grpc_response, response
assert_equal grpc_operation, operation
end
# Use hash object with options
client.create_attestor({ parent: parent, attestor_id: attestor_id, attestor: attestor }, grpc_options) do |response, operation|
assert_equal grpc_response, response
assert_equal grpc_operation, operation
end
# Use protobuf object with options
client.create_attestor(::Google::Cloud::BinaryAuthorization::V1beta1::CreateAttestorRequest.new(parent: parent, attestor_id: attestor_id, attestor: attestor), grpc_options) do |response, operation|
assert_equal grpc_response, response
assert_equal grpc_operation, operation
end
# Verify method calls
assert_equal 5, create_attestor_client_stub.call_rpc_count
end
end
def test_get_attestor
# Create GRPC objects.
grpc_response = ::Google::Cloud::BinaryAuthorization::V1beta1::Attestor.new
grpc_operation = GRPC::ActiveCall::Operation.new nil
grpc_channel = GRPC::Core::Channel.new "localhost:8888", nil, :this_channel_is_insecure
grpc_options = {}
# Create request parameters for a unary method.
name = "hello world"
get_attestor_client_stub = ClientStub.new grpc_response, grpc_operation do |name, request, options:|
assert_equal :get_attestor, name
assert_kind_of ::Google::Cloud::BinaryAuthorization::V1beta1::GetAttestorRequest, request
assert_equal "hello world", request["name"]
refute_nil options
end
Gapic::ServiceStub.stub :new, get_attestor_client_stub do
# Create client
client = ::Google::Cloud::BinaryAuthorization::V1beta1::BinauthzManagementService::Client.new do |config|
config.credentials = grpc_channel
end
# Use hash object
client.get_attestor({ name: name }) do |response, operation|
assert_equal grpc_response, response
assert_equal grpc_operation, operation
end
# Use named arguments
client.get_attestor name: name do |response, operation|
assert_equal grpc_response, response
assert_equal grpc_operation, operation
end
# Use protobuf object
client.get_attestor ::Google::Cloud::BinaryAuthorization::V1beta1::GetAttestorRequest.new(name: name) do |response, operation|
assert_equal grpc_response, response
assert_equal grpc_operation, operation
end
# Use hash object with options
client.get_attestor({ name: name }, grpc_options) do |response, operation|
assert_equal grpc_response, response
assert_equal grpc_operation, operation
end
# Use protobuf object with options
client.get_attestor(::Google::Cloud::BinaryAuthorization::V1beta1::GetAttestorRequest.new(name: name), grpc_options) do |response, operation|
assert_equal grpc_response, response
assert_equal grpc_operation, operation
end
# Verify method calls
assert_equal 5, get_attestor_client_stub.call_rpc_count
end
end
def test_update_attestor
# Create GRPC objects.
grpc_response = ::Google::Cloud::BinaryAuthorization::V1beta1::Attestor.new
grpc_operation = GRPC::ActiveCall::Operation.new nil
grpc_channel = GRPC::Core::Channel.new "localhost:8888", nil, :this_channel_is_insecure
grpc_options = {}
# Create request parameters for a unary method.
attestor = {}
update_attestor_client_stub = ClientStub.new grpc_response, grpc_operation do |name, request, options:|
assert_equal :update_attestor, name
assert_kind_of ::Google::Cloud::BinaryAuthorization::V1beta1::UpdateAttestorRequest, request
assert_equal Gapic::Protobuf.coerce({}, to: ::Google::Cloud::BinaryAuthorization::V1beta1::Attestor), request["attestor"]
refute_nil options
end
Gapic::ServiceStub.stub :new, update_attestor_client_stub do
# Create client
client = ::Google::Cloud::BinaryAuthorization::V1beta1::BinauthzManagementService::Client.new do |config|
config.credentials = grpc_channel
end
# Use hash object
client.update_attestor({ attestor: attestor }) do |response, operation|
assert_equal grpc_response, response
assert_equal grpc_operation, operation
end
# Use named arguments
client.update_attestor attestor: attestor do |response, operation|
assert_equal grpc_response, response
assert_equal grpc_operation, operation
end
# Use protobuf object
client.update_attestor ::Google::Cloud::BinaryAuthorization::V1beta1::UpdateAttestorRequest.new(attestor: attestor) do |response, operation|
assert_equal grpc_response, response
assert_equal grpc_operation, operation
end
# Use hash object with options
client.update_attestor({ attestor: attestor }, grpc_options) do |response, operation|
assert_equal grpc_response, response
assert_equal grpc_operation, operation
end
# Use protobuf object with options
client.update_attestor(::Google::Cloud::BinaryAuthorization::V1beta1::UpdateAttestorRequest.new(attestor: attestor), grpc_options) do |response, operation|
assert_equal grpc_response, response
assert_equal grpc_operation, operation
end
# Verify method calls
assert_equal 5, update_attestor_client_stub.call_rpc_count
end
end
def test_list_attestors
# Create GRPC objects.
grpc_response = ::Google::Cloud::BinaryAuthorization::V1beta1::ListAttestorsResponse.new
grpc_operation = GRPC::ActiveCall::Operation.new nil
grpc_channel = GRPC::Core::Channel.new "localhost:8888", nil, :this_channel_is_insecure
grpc_options = {}
# Create request parameters for a unary method.
parent = "hello world"
page_size = 42
page_token = "hello world"
list_attestors_client_stub = ClientStub.new grpc_response, grpc_operation do |name, request, options:|
assert_equal :list_attestors, name
assert_kind_of ::Google::Cloud::BinaryAuthorization::V1beta1::ListAttestorsRequest, request
assert_equal "hello world", request["parent"]
assert_equal 42, request["page_size"]
assert_equal "hello world", request["page_token"]
refute_nil options
end
Gapic::ServiceStub.stub :new, list_attestors_client_stub do
# Create client
client = ::Google::Cloud::BinaryAuthorization::V1beta1::BinauthzManagementService::Client.new do |config|
config.credentials = grpc_channel
end
# Use hash object
client.list_attestors({ parent: parent, page_size: page_size, page_token: page_token }) do |response, operation|
assert_kind_of Gapic::PagedEnumerable, response
assert_equal grpc_response, response.response
assert_equal grpc_operation, operation
end
# Use named arguments
client.list_attestors parent: parent, page_size: page_size, page_token: page_token do |response, operation|
assert_kind_of Gapic::PagedEnumerable, response
assert_equal grpc_response, response.response
assert_equal grpc_operation, operation
end
# Use protobuf object
client.list_attestors ::Google::Cloud::BinaryAuthorization::V1beta1::ListAttestorsRequest.new(parent: parent, page_size: page_size, page_token: page_token) do |response, operation|
assert_kind_of Gapic::PagedEnumerable, response
assert_equal grpc_response, response.response
assert_equal grpc_operation, operation
end
# Use hash object with options
client.list_attestors({ parent: parent, page_size: page_size, page_token: page_token }, grpc_options) do |response, operation|
assert_kind_of Gapic::PagedEnumerable, response
assert_equal grpc_response, response.response
assert_equal grpc_operation, operation
end
# Use protobuf object with options
client.list_attestors(::Google::Cloud::BinaryAuthorization::V1beta1::ListAttestorsRequest.new(parent: parent, page_size: page_size, page_token: page_token), grpc_options) do |response, operation|
assert_kind_of Gapic::PagedEnumerable, response
assert_equal grpc_response, response.response
assert_equal grpc_operation, operation
end
# Verify method calls
assert_equal 5, list_attestors_client_stub.call_rpc_count
end
end
def test_delete_attestor
# Create GRPC objects.
grpc_response = ::Google::Protobuf::Empty.new
grpc_operation = GRPC::ActiveCall::Operation.new nil
grpc_channel = GRPC::Core::Channel.new "localhost:8888", nil, :this_channel_is_insecure
grpc_options = {}
# Create request parameters for a unary method.
name = "hello world"
delete_attestor_client_stub = ClientStub.new grpc_response, grpc_operation do |name, request, options:|
assert_equal :delete_attestor, name
assert_kind_of ::Google::Cloud::BinaryAuthorization::V1beta1::DeleteAttestorRequest, request
assert_equal "hello world", request["name"]
refute_nil options
end
Gapic::ServiceStub.stub :new, delete_attestor_client_stub do
# Create client
client = ::Google::Cloud::BinaryAuthorization::V1beta1::BinauthzManagementService::Client.new do |config|
config.credentials = grpc_channel
end
# Use hash object
client.delete_attestor({ name: name }) do |response, operation|
assert_equal grpc_response, response
assert_equal grpc_operation, operation
end
# Use named arguments
client.delete_attestor name: name do |response, operation|
assert_equal grpc_response, response
assert_equal grpc_operation, operation
end
# Use protobuf object
client.delete_attestor ::Google::Cloud::BinaryAuthorization::V1beta1::DeleteAttestorRequest.new(name: name) do |response, operation|
assert_equal grpc_response, response
assert_equal grpc_operation, operation
end
# Use hash object with options
client.delete_attestor({ name: name }, grpc_options) do |response, operation|
assert_equal grpc_response, response
assert_equal grpc_operation, operation
end
# Use protobuf object with options
client.delete_attestor(::Google::Cloud::BinaryAuthorization::V1beta1::DeleteAttestorRequest.new(name: name), grpc_options) do |response, operation|
assert_equal grpc_response, response
assert_equal grpc_operation, operation
end
# Verify method calls
assert_equal 5, delete_attestor_client_stub.call_rpc_count
end
end
def test_configure
grpc_channel = GRPC::Core::Channel.new "localhost:8888", nil, :this_channel_is_insecure
client = block_config = config = nil
Gapic::ServiceStub.stub :new, nil do
client = ::Google::Cloud::BinaryAuthorization::V1beta1::BinauthzManagementService::Client.new do |config|
config.credentials = grpc_channel
end
end
config = client.configure do |c|
block_config = c
end
assert_same block_config, config
assert_kind_of ::Google::Cloud::BinaryAuthorization::V1beta1::BinauthzManagementService::Client::Configuration, config
end
end
| 39.359343 | 203 | 0.722767 |
086e1394bf86ba33b78e9a2b2fafc7276356e3bd | 340 | module ReviewsHelper
def display_heading(object)
if object
content_tag(:h1, "Reviews for #{object.title}")
else
content_tag(:h1, "All Reviews")
end
end
def go_back(recipe)
if recipe
link_to "Back", recipe_path(recipe), class: "btn btn-dark"
else
link_to "Back", recipes_path, class: "btn btn-dark"
end
end
end
| 17.894737 | 61 | 0.694118 |
1d052fb22cc205099fb67a82885460148a1d60a2 | 771 | # frozen_string_literal: true
module CaseMixHelper
CASE_MIX_TIERS = %i[a b c d na].freeze
def case_mix_key
render partial: 'poms/case-mix/key', locals: { tiers: CASE_MIX_TIERS }
end
def case_mix_bar(pom)
tiers = {
a: pom.tier_a,
b: pom.tier_b,
c: pom.tier_c,
d: pom.tier_d,
na: pom.no_tier,
}.reject { |_tier, count| count.zero? } # filter out zero-count tiers
css_columns = tiers.values.map { |count|
# Value for CSS property grid-template-columns
%W[0 #{count}fr]
}.join(' ')
render partial: 'poms/case-mix/bar', locals: { tiers: tiers, css_columns: css_columns }
end
def tier_label(tier)
if tier == :na
'Tier N/A'
else
"Tier #{tier.to_s.upcase}"
end
end
end
| 22.028571 | 91 | 0.616083 |
1dd05b8373d513db26856bbed67a04620bfdd92a | 640 | $: << File.join(File.dirname(__FILE__), '..', 'lib')
require 'rubygems'
require '../lib/rturk'
require 'yaml'
aws = YAML.load(File.open(File.join(File.dirname(__FILE__), 'mturk.yml')))
RTurk::setup(aws['AWSAccessKeyId'], aws['AWSAccessKey'])
file = File.open(File.join(File.dirname(__FILE__), 'answers.yml'), 'w')
hits = RTurk::Hit.all_reviewable
puts "#{hits.size} reviewable hits. \n"
unless hits.empty?
puts "Reviewing all assignments"
hits.each do |hit|
hit.assignments.each do |assignment|
file.puts assignment.answers.to_hash.to_yaml
assignment.approve! if assignment.status == 'Submitted'
end
end
end | 27.826087 | 74 | 0.698438 |
ede3a4409037ac16a7f3a697f822561f234ec42d | 83,164 | require "cases/helper"
require "models/developer"
require "models/computer"
require "models/project"
require "models/company"
require "models/contract"
require "models/topic"
require "models/reply"
require "models/category"
require "models/image"
require "models/post"
require "models/author"
require "models/essay"
require "models/comment"
require "models/person"
require "models/reader"
require "models/tagging"
require "models/tag"
require "models/invoice"
require "models/line_item"
require "models/car"
require "models/bulb"
require "models/engine"
require "models/categorization"
require "models/minivan"
require "models/speedometer"
require "models/reference"
require "models/job"
require "models/college"
require "models/student"
require "models/pirate"
require "models/ship"
require "models/ship_part"
require "models/treasure"
require "models/parrot"
require "models/tyre"
require "models/subscriber"
require "models/subscription"
require "models/zine"
require "models/interest"
class HasManyAssociationsTestForReorderWithJoinDependency < ActiveRecord::TestCase
fixtures :authors, :posts, :comments
def test_should_generate_valid_sql
author = authors(:david)
# this can fail on adapters which require ORDER BY expressions to be included in the SELECT expression
# if the reorder clauses are not correctly handled
assert author.posts_with_comments_sorted_by_comment_id.where("comments.id > 0").reorder("posts.comments_count DESC", "posts.tags_count DESC").last
end
end
class HasManyAssociationsTestPrimaryKeys < ActiveRecord::TestCase
fixtures :authors, :essays, :subscribers, :subscriptions, :people
def test_custom_primary_key_on_new_record_should_fetch_with_query
subscriber = Subscriber.new(nick: "webster132")
assert !subscriber.subscriptions.loaded?
assert_queries 1 do
assert_equal 2, subscriber.subscriptions.size
end
assert_equal subscriber.subscriptions, Subscription.where(subscriber_id: "webster132")
end
def test_association_primary_key_on_new_record_should_fetch_with_query
author = Author.new(name: "David")
assert !author.essays.loaded?
assert_queries 1 do
assert_equal 1, author.essays.size
end
assert_equal author.essays, Essay.where(writer_id: "David")
end
def test_has_many_custom_primary_key
david = authors(:david)
assert_equal david.essays, Essay.where(writer_id: "David")
end
def test_has_many_assignment_with_custom_primary_key
david = people(:david)
assert_equal ["A Modest Proposal"], david.essays.map(&:name)
david.essays = [Essay.create!(name: "Remote Work")]
assert_equal ["Remote Work"], david.essays.map(&:name)
end
def test_blank_custom_primary_key_on_new_record_should_not_run_queries
author = Author.new
assert !author.essays.loaded?
assert_queries 0 do
assert_equal 0, author.essays.size
end
end
end
class HasManyAssociationsTest < ActiveRecord::TestCase
fixtures :accounts, :categories, :companies, :developers, :projects,
:developers_projects, :topics, :authors, :comments,
:posts, :readers, :taggings, :cars, :jobs, :tags,
:categorizations, :zines, :interests
def setup
Client.destroyed_client_ids.clear
end
def test_sti_subselect_count
tag = Tag.first
len = Post.tagged_with(tag.id).limit(10).size
assert_operator len, :>, 0
end
def test_anonymous_has_many
developer = Class.new(ActiveRecord::Base) {
self.table_name = "developers"
dev = self
developer_project = Class.new(ActiveRecord::Base) {
self.table_name = "developers_projects"
belongs_to :developer, anonymous_class: dev
}
has_many :developer_projects, anonymous_class: developer_project, foreign_key: "developer_id"
}
dev = developer.first
named = Developer.find(dev.id)
assert_operator dev.developer_projects.count, :>, 0
assert_equal named.projects.map(&:id).sort,
dev.developer_projects.map(&:project_id).sort
end
def test_default_scope_on_relations_is_not_cached
counter = 0
posts = Class.new(ActiveRecord::Base) {
self.table_name = "posts"
self.inheritance_column = "not_there"
post = self
comments = Class.new(ActiveRecord::Base) {
self.table_name = "comments"
self.inheritance_column = "not_there"
belongs_to :post, anonymous_class: post
default_scope -> {
counter += 1
where("id = :inc", inc: counter)
}
}
has_many :comments, anonymous_class: comments, foreign_key: "post_id"
}
assert_equal 0, counter
post = posts.first
assert_equal 0, counter
sql = capture_sql { post.comments.to_a }
post.comments.reset
assert_not_equal sql, capture_sql { post.comments.to_a }
end
def test_has_many_build_with_options
college = College.create(name: "UFMT")
Student.create(active: true, college_id: college.id, name: "Sarah")
assert_equal college.students, Student.where(active: true, college_id: college.id)
end
def test_add_record_to_collection_should_change_its_updated_at
ship = Ship.create(name: "dauntless")
part = ShipPart.create(name: "cockpit")
updated_at = part.updated_at
travel(1.second) do
ship.parts << part
end
assert_equal part.ship, ship
assert_not_equal part.updated_at, updated_at
end
def test_clear_collection_should_not_change_updated_at
# GH#17161: .clear calls delete_all (and returns the association),
# which is intended to not touch associated objects's updated_at field
ship = Ship.create(name: "dauntless")
part = ShipPart.create(name: "cockpit", ship_id: ship.id)
ship.parts.clear
part.reload
assert_nil part.ship
assert !part.updated_at_changed?
end
def test_create_from_association_should_respect_default_scope
car = Car.create(name: "honda")
assert_equal "honda", car.name
bulb = Bulb.create
assert_equal "defaulty", bulb.name
bulb = car.bulbs.build
assert_equal "defaulty", bulb.name
bulb = car.bulbs.create
assert_equal "defaulty", bulb.name
end
def test_build_and_create_from_association_should_respect_passed_attributes_over_default_scope
car = Car.create(name: "honda")
bulb = car.bulbs.build(name: "exotic")
assert_equal "exotic", bulb.name
bulb = car.bulbs.create(name: "exotic")
assert_equal "exotic", bulb.name
bulb = car.awesome_bulbs.build(frickinawesome: false)
assert_equal false, bulb.frickinawesome
bulb = car.awesome_bulbs.create(frickinawesome: false)
assert_equal false, bulb.frickinawesome
end
def test_build_from_association_should_respect_scope
author = Author.new
post = author.thinking_posts.build
assert_equal "So I was thinking", post.title
end
def test_create_from_association_with_nil_values_should_work
car = Car.create(name: "honda")
bulb = car.bulbs.new(nil)
assert_equal "defaulty", bulb.name
bulb = car.bulbs.build(nil)
assert_equal "defaulty", bulb.name
bulb = car.bulbs.create(nil)
assert_equal "defaulty", bulb.name
end
def test_do_not_call_callbacks_for_delete_all
car = Car.create(name: "honda")
car.funky_bulbs.create!
assert_equal 1, car.funky_bulbs.count
assert_nothing_raised { car.reload.funky_bulbs.delete_all }
assert_equal 0, car.funky_bulbs.count, "bulbs should have been deleted using :delete_all strategy"
end
def test_delete_all_on_association_is_the_same_as_not_loaded
author = authors :david
author.thinking_posts.create!(body: "test")
author.reload
expected_sql = capture_sql { author.thinking_posts.delete_all }
author.thinking_posts.create!(body: "test")
author.reload
author.thinking_posts.inspect
loaded_sql = capture_sql { author.thinking_posts.delete_all }
assert_equal(expected_sql, loaded_sql)
end
def test_delete_all_on_association_with_nil_dependency_is_the_same_as_not_loaded
author = authors :david
author.posts.create!(title: "test", body: "body")
author.reload
expected_sql = capture_sql { author.posts.delete_all }
author.posts.create!(title: "test", body: "body")
author.reload
author.posts.to_a
loaded_sql = capture_sql { author.posts.delete_all }
assert_equal(expected_sql, loaded_sql)
end
def test_building_the_associated_object_with_implicit_sti_base_class
firm = DependentFirm.new
company = firm.companies.build
assert_kind_of Company, company, "Expected #{company.class} to be a Company"
end
def test_building_the_associated_object_with_explicit_sti_base_class
firm = DependentFirm.new
company = firm.companies.build(type: "Company")
assert_kind_of Company, company, "Expected #{company.class} to be a Company"
end
def test_building_the_associated_object_with_sti_subclass
firm = DependentFirm.new
company = firm.companies.build(type: "Client")
assert_kind_of Client, company, "Expected #{company.class} to be a Client"
end
def test_building_the_associated_object_with_an_invalid_type
firm = DependentFirm.new
assert_raise(ActiveRecord::SubclassNotFound) { firm.companies.build(type: "Invalid") }
end
def test_building_the_associated_object_with_an_unrelated_type
firm = DependentFirm.new
assert_raise(ActiveRecord::SubclassNotFound) { firm.companies.build(type: "Account") }
end
test "building the association with an array" do
speedometer = Speedometer.new(speedometer_id: "a")
data = [{ name: "first" }, { name: "second" }]
speedometer.minivans.build(data)
assert_equal 2, speedometer.minivans.size
assert speedometer.save
assert_equal ["first", "second"], speedometer.reload.minivans.map(&:name)
end
def test_association_keys_bypass_attribute_protection
car = Car.create(name: "honda")
bulb = car.bulbs.new
assert_equal car.id, bulb.car_id
bulb = car.bulbs.new car_id: car.id + 1
assert_equal car.id, bulb.car_id
bulb = car.bulbs.build
assert_equal car.id, bulb.car_id
bulb = car.bulbs.build car_id: car.id + 1
assert_equal car.id, bulb.car_id
bulb = car.bulbs.create
assert_equal car.id, bulb.car_id
bulb = car.bulbs.create car_id: car.id + 1
assert_equal car.id, bulb.car_id
end
def test_association_protect_foreign_key
invoice = Invoice.create
line_item = invoice.line_items.new
assert_equal invoice.id, line_item.invoice_id
line_item = invoice.line_items.new invoice_id: invoice.id + 1
assert_equal invoice.id, line_item.invoice_id
line_item = invoice.line_items.build
assert_equal invoice.id, line_item.invoice_id
line_item = invoice.line_items.build invoice_id: invoice.id + 1
assert_equal invoice.id, line_item.invoice_id
line_item = invoice.line_items.create
assert_equal invoice.id, line_item.invoice_id
line_item = invoice.line_items.create invoice_id: invoice.id + 1
assert_equal invoice.id, line_item.invoice_id
end
# When creating objects on the association, we must not do it within a scope (even though it
# would be convenient), because this would cause that scope to be applied to any callbacks etc.
def test_build_and_create_should_not_happen_within_scope
car = cars(:honda)
scope = car.foo_bulbs.where_values_hash
bulb = car.foo_bulbs.build
assert_not_equal scope, bulb.scope_after_initialize.where_values_hash
bulb = car.foo_bulbs.create
assert_not_equal scope, bulb.scope_after_initialize.where_values_hash
bulb = car.foo_bulbs.create!
assert_not_equal scope, bulb.scope_after_initialize.where_values_hash
end
def test_no_sql_should_be_fired_if_association_already_loaded
Car.create(name: "honda")
bulbs = Car.first.bulbs
bulbs.to_a # to load all instances of bulbs
assert_no_queries do
bulbs.first()
end
assert_no_queries do
bulbs.second()
end
assert_no_queries do
bulbs.third()
end
assert_no_queries do
bulbs.fourth()
end
assert_no_queries do
bulbs.fifth()
end
assert_no_queries do
bulbs.forty_two()
end
assert_no_queries do
bulbs.third_to_last()
end
assert_no_queries do
bulbs.second_to_last()
end
assert_no_queries do
bulbs.last()
end
end
def test_finder_method_with_dirty_target
company = companies(:first_firm)
new_clients = []
assert_no_queries(ignore_none: false) do
new_clients << company.clients_of_firm.build(name: "Another Client")
new_clients << company.clients_of_firm.build(name: "Another Client II")
new_clients << company.clients_of_firm.build(name: "Another Client III")
end
assert_not company.clients_of_firm.loaded?
assert_queries(1) do
assert_same new_clients[0], company.clients_of_firm.third
assert_same new_clients[1], company.clients_of_firm.fourth
assert_same new_clients[2], company.clients_of_firm.fifth
assert_same new_clients[0], company.clients_of_firm.third_to_last
assert_same new_clients[1], company.clients_of_firm.second_to_last
assert_same new_clients[2], company.clients_of_firm.last
end
end
def test_finder_bang_method_with_dirty_target
company = companies(:first_firm)
new_clients = []
assert_no_queries(ignore_none: false) do
new_clients << company.clients_of_firm.build(name: "Another Client")
new_clients << company.clients_of_firm.build(name: "Another Client II")
new_clients << company.clients_of_firm.build(name: "Another Client III")
end
assert_not company.clients_of_firm.loaded?
assert_queries(1) do
assert_same new_clients[0], company.clients_of_firm.third!
assert_same new_clients[1], company.clients_of_firm.fourth!
assert_same new_clients[2], company.clients_of_firm.fifth!
assert_same new_clients[0], company.clients_of_firm.third_to_last!
assert_same new_clients[1], company.clients_of_firm.second_to_last!
assert_same new_clients[2], company.clients_of_firm.last!
end
end
def test_create_resets_cached_counters
person = Person.create!(first_name: "tenderlove")
post = Post.first
assert_equal [], person.readers
assert_nil person.readers.find_by_post_id(post.id)
person.readers.create(post_id: post.id)
assert_equal 1, person.readers.count
assert_equal 1, person.readers.length
assert_equal post, person.readers.first.post
assert_equal person, person.readers.first.person
end
def test_update_all_respects_association_scope
person = Person.new
person.first_name = "Naruto"
person.references << Reference.new
person.id = 10
person.references
person.save!
assert_equal 1, person.references.update_all(favourite: true)
end
def test_exists_respects_association_scope
person = Person.new
person.first_name = "Sasuke"
person.references << Reference.new
person.id = 10
person.references
person.save!
assert_predicate person.references, :exists?
end
# sometimes tests on Oracle fail if ORDER BY is not provided therefore add always :order with :first
def test_counting_with_counter_sql
assert_equal 3, Firm.all.merge!(order: "id").first.clients.count
end
def test_counting
assert_equal 3, Firm.all.merge!(order: "id").first.plain_clients.count
end
def test_counting_with_single_hash
assert_equal 1, Firm.all.merge!(order: "id").first.plain_clients.where(name: "Microsoft").count
end
def test_counting_with_column_name_and_hash
assert_equal 3, Firm.all.merge!(order: "id").first.plain_clients.count(:name)
end
def test_counting_with_association_limit
firm = companies(:first_firm)
assert_equal firm.limited_clients.length, firm.limited_clients.size
assert_equal firm.limited_clients.length, firm.limited_clients.count
end
def test_finding
assert_equal 3, Firm.all.merge!(order: "id").first.clients.length
end
def test_finding_array_compatibility
assert_equal 3, Firm.order(:id).find { |f| f.id > 0 }.clients.length
end
def test_find_many_with_merged_options
assert_equal 1, companies(:first_firm).limited_clients.size
assert_equal 1, companies(:first_firm).limited_clients.to_a.size
assert_equal 3, companies(:first_firm).limited_clients.limit(nil).to_a.size
end
def test_find_should_append_to_association_order
ordered_clients = companies(:first_firm).clients_sorted_desc.order("companies.id")
assert_equal ["id DESC", "companies.id"], ordered_clients.order_values
end
def test_dynamic_find_should_respect_association_order
assert_equal companies(:another_first_firm_client), companies(:first_firm).clients_sorted_desc.where("type = 'Client'").first
assert_equal companies(:another_first_firm_client), companies(:first_firm).clients_sorted_desc.find_by_type("Client")
end
def test_taking
posts(:other_by_bob).destroy
assert_equal posts(:misc_by_bob), authors(:bob).posts.take
assert_equal posts(:misc_by_bob), authors(:bob).posts.take!
authors(:bob).posts.to_a
assert_equal posts(:misc_by_bob), authors(:bob).posts.take
assert_equal posts(:misc_by_bob), authors(:bob).posts.take!
end
def test_taking_not_found
authors(:bob).posts.delete_all
assert_raise(ActiveRecord::RecordNotFound) { authors(:bob).posts.take! }
authors(:bob).posts.to_a
assert_raise(ActiveRecord::RecordNotFound) { authors(:bob).posts.take! }
end
def test_taking_with_a_number
# taking from unloaded Relation
bob = Author.find(authors(:bob).id)
new_post = bob.posts.build
assert_not bob.posts.loaded?
assert_equal [posts(:misc_by_bob)], bob.posts.take(1)
assert_equal [posts(:misc_by_bob), posts(:other_by_bob)], bob.posts.take(2)
assert_equal [posts(:misc_by_bob), posts(:other_by_bob), new_post], bob.posts.take(3)
# taking from loaded Relation
bob.posts.load
assert bob.posts.loaded?
assert_equal [posts(:misc_by_bob)], bob.posts.take(1)
assert_equal [posts(:misc_by_bob), posts(:other_by_bob)], bob.posts.take(2)
assert_equal [posts(:misc_by_bob), posts(:other_by_bob), new_post], bob.posts.take(3)
end
def test_taking_with_inverse_of
interests(:woodsmanship).destroy
interests(:survival).destroy
zine = zines(:going_out)
interest = zine.interests.take
assert_equal interests(:hunting), interest
assert_same zine, interest.zine
end
def test_cant_save_has_many_readonly_association
authors(:david).readonly_comments.each { |c| assert_raise(ActiveRecord::ReadOnlyRecord) { c.save! } }
authors(:david).readonly_comments.each { |c| assert c.readonly? }
end
def test_finding_default_orders
assert_equal "Summit", Firm.all.merge!(order: "id").first.clients.first.name
end
def test_finding_with_different_class_name_and_order
assert_equal "Apex", Firm.all.merge!(order: "id").first.clients_sorted_desc.first.name
end
def test_finding_with_foreign_key
assert_equal "Microsoft", Firm.all.merge!(order: "id").first.clients_of_firm.first.name
end
def test_finding_with_condition
assert_equal "Microsoft", Firm.all.merge!(order: "id").first.clients_like_ms.first.name
end
def test_finding_with_condition_hash
assert_equal "Microsoft", Firm.all.merge!(order: "id").first.clients_like_ms_with_hash_conditions.first.name
end
def test_finding_using_primary_key
assert_equal "Summit", Firm.all.merge!(order: "id").first.clients_using_primary_key.first.name
end
def test_update_all_on_association_accessed_before_save
firm = Firm.new(name: "Firm")
firm.clients << Client.first
firm.save!
assert_equal firm.clients.count, firm.clients.update_all(description: "Great!")
end
def test_update_all_on_association_accessed_before_save_with_explicit_foreign_key
firm = Firm.new(name: "Firm", id: 100)
firm.clients << Client.first
firm.save!
assert_equal firm.clients.count, firm.clients.update_all(description: "Great!")
end
def test_belongs_to_sanity
c = Client.new
assert_nil c.firm, "belongs_to failed sanity check on new object"
end
def test_find_ids
firm = Firm.all.merge!(order: "id").first
assert_raise(ActiveRecord::RecordNotFound) { firm.clients.find }
client = firm.clients.find(2)
assert_kind_of Client, client
client_ary = firm.clients.find([2])
assert_kind_of Array, client_ary
assert_equal client, client_ary.first
client_ary = firm.clients.find(2, 3)
assert_kind_of Array, client_ary
assert_equal 2, client_ary.size
assert_equal client, client_ary.first
assert_raise(ActiveRecord::RecordNotFound) { firm.clients.find(2, 99) }
end
def test_find_one_message_on_primary_key
firm = Firm.all.merge!(order: "id").first
e = assert_raises(ActiveRecord::RecordNotFound) do
firm.clients.find(0)
end
assert_equal 0, e.id
assert_equal "id", e.primary_key
assert_equal "Client", e.model
assert_match (/\ACouldn't find Client with 'id'=0/), e.message
end
def test_find_ids_and_inverse_of
force_signal37_to_load_all_clients_of_firm
assert_predicate companies(:first_firm).clients_of_firm, :loaded?
firm = companies(:first_firm)
client = firm.clients_of_firm.find(3)
assert_kind_of Client, client
client_ary = firm.clients_of_firm.find([3])
assert_kind_of Array, client_ary
assert_equal client, client_ary.first
end
def test_find_all
firm = Firm.all.merge!(order: "id").first
assert_equal 3, firm.clients.where("#{QUOTED_TYPE} = 'Client'").to_a.length
assert_equal 1, firm.clients.where("name = 'Summit'").to_a.length
end
def test_find_each
firm = companies(:first_firm)
assert ! firm.clients.loaded?
assert_queries(4) do
firm.clients.find_each(batch_size: 1) { |c| assert_equal firm.id, c.firm_id }
end
assert ! firm.clients.loaded?
end
def test_find_each_with_conditions
firm = companies(:first_firm)
assert_queries(2) do
firm.clients.where(name: "Microsoft").find_each(batch_size: 1) do |c|
assert_equal firm.id, c.firm_id
assert_equal "Microsoft", c.name
end
end
assert ! firm.clients.loaded?
end
def test_find_in_batches
firm = companies(:first_firm)
assert ! firm.clients.loaded?
assert_queries(2) do
firm.clients.find_in_batches(batch_size: 2) do |clients|
clients.each { |c| assert_equal firm.id, c.firm_id }
end
end
assert ! firm.clients.loaded?
end
def test_find_all_sanitized
# sometimes tests on Oracle fail if ORDER BY is not provided therefore add always :order with :first
firm = Firm.all.merge!(order: "id").first
summit = firm.clients.where("name = 'Summit'").to_a
assert_equal summit, firm.clients.where("name = ?", "Summit").to_a
assert_equal summit, firm.clients.where("name = :name", name: "Summit").to_a
end
def test_find_first
firm = Firm.all.merge!(order: "id").first
client2 = Client.find(2)
assert_equal firm.clients.first, firm.clients.order("id").first
assert_equal client2, firm.clients.where("#{QUOTED_TYPE} = 'Client'").order("id").first
end
def test_find_first_sanitized
firm = Firm.all.merge!(order: "id").first
client2 = Client.find(2)
assert_equal client2, firm.clients.merge!(where: ["#{QUOTED_TYPE} = ?", "Client"], order: "id").first
assert_equal client2, firm.clients.merge!(where: ["#{QUOTED_TYPE} = :type", { type: "Client" }], order: "id").first
end
def test_find_all_with_include_and_conditions
assert_nothing_raised do
Developer.all.merge!(joins: :audit_logs, where: { "audit_logs.message" => nil, :name => "Smith" }).to_a
end
end
def test_find_in_collection
assert_equal Client.find(2).name, companies(:first_firm).clients.find(2).name
assert_raise(ActiveRecord::RecordNotFound) { companies(:first_firm).clients.find(6) }
end
def test_find_grouped
all_clients_of_firm1 = Client.all.merge!(where: "firm_id = 1").to_a
grouped_clients_of_firm1 = Client.all.merge!(where: "firm_id = 1", group: "firm_id", select: "firm_id, count(id) as clients_count").to_a
assert_equal 3, all_clients_of_firm1.size
assert_equal 1, grouped_clients_of_firm1.size
end
def test_find_scoped_grouped
assert_equal 1, companies(:first_firm).clients_grouped_by_firm_id.size
assert_equal 1, companies(:first_firm).clients_grouped_by_firm_id.length
assert_equal 3, companies(:first_firm).clients_grouped_by_name.size
assert_equal 3, companies(:first_firm).clients_grouped_by_name.length
end
def test_find_scoped_grouped_having
assert_equal 1, authors(:david).popular_grouped_posts.length
assert_equal 0, authors(:mary).popular_grouped_posts.length
end
def test_default_select
assert_equal Comment.column_names.sort, posts(:welcome).comments.first.attributes.keys.sort
end
def test_select_query_method
assert_equal ["id", "body"], posts(:welcome).comments.select(:id, :body).first.attributes.keys
end
def test_select_with_block
assert_equal [1], posts(:welcome).comments.select { |c| c.id == 1 }.map(&:id)
end
def test_select_without_foreign_key
assert_equal companies(:first_firm).accounts.first.credit_limit, companies(:first_firm).accounts.select(:credit_limit).first.credit_limit
end
def test_adding
force_signal37_to_load_all_clients_of_firm
assert_predicate companies(:first_firm).clients_of_firm, :loaded?
natural = Client.new("name" => "Natural Company")
companies(:first_firm).clients_of_firm << natural
assert_equal 3, companies(:first_firm).clients_of_firm.size # checking via the collection
assert_equal 3, companies(:first_firm).clients_of_firm.reload.size # checking using the db
assert_equal natural, companies(:first_firm).clients_of_firm.last
end
def test_adding_using_create
first_firm = companies(:first_firm)
assert_equal 3, first_firm.plain_clients.size
first_firm.plain_clients.create(name: "Natural Company")
assert_equal 4, first_firm.plain_clients.length
assert_equal 4, first_firm.plain_clients.size
end
def test_create_with_bang_on_has_many_when_parent_is_new_raises
error = assert_raise(ActiveRecord::RecordNotSaved) do
firm = Firm.new
firm.plain_clients.create! name: "Whoever"
end
assert_equal "You cannot call create unless the parent is saved", error.message
end
def test_regular_create_on_has_many_when_parent_is_new_raises
error = assert_raise(ActiveRecord::RecordNotSaved) do
firm = Firm.new
firm.plain_clients.create name: "Whoever"
end
assert_equal "You cannot call create unless the parent is saved", error.message
end
def test_create_with_bang_on_has_many_raises_when_record_not_saved
assert_raise(ActiveRecord::RecordInvalid) do
firm = Firm.all.merge!(order: "id").first
firm.plain_clients.create!
end
end
def test_create_with_bang_on_habtm_when_parent_is_new_raises
error = assert_raise(ActiveRecord::RecordNotSaved) do
Developer.new("name" => "Aredridel").projects.create!
end
assert_equal "You cannot call create unless the parent is saved", error.message
end
def test_adding_a_mismatch_class
assert_raise(ActiveRecord::AssociationTypeMismatch) { companies(:first_firm).clients_of_firm << nil }
assert_raise(ActiveRecord::AssociationTypeMismatch) { companies(:first_firm).clients_of_firm << 1 }
assert_raise(ActiveRecord::AssociationTypeMismatch) { companies(:first_firm).clients_of_firm << Topic.find(1) }
end
def test_adding_a_collection
force_signal37_to_load_all_clients_of_firm
assert_predicate companies(:first_firm).clients_of_firm, :loaded?
companies(:first_firm).clients_of_firm.concat([Client.new("name" => "Natural Company"), Client.new("name" => "Apple")])
assert_equal 4, companies(:first_firm).clients_of_firm.size
assert_equal 4, companies(:first_firm).clients_of_firm.reload.size
end
def test_transactions_when_adding_to_persisted
good = Client.new(name: "Good")
bad = Client.new(name: "Bad", raise_on_save: true)
begin
companies(:first_firm).clients_of_firm.concat(good, bad)
rescue Client::RaisedOnSave
end
assert_not_includes companies(:first_firm).clients_of_firm.reload, good
end
def test_transactions_when_adding_to_new_record
assert_no_queries(ignore_none: false) do
firm = Firm.new
firm.clients_of_firm.concat(Client.new("name" => "Natural Company"))
end
end
def test_inverse_on_before_validate
firm = companies(:first_firm)
assert_queries(1) do
firm.clients_of_firm << Client.new("name" => "Natural Company")
end
end
def test_new_aliased_to_build
company = companies(:first_firm)
new_client = assert_no_queries(ignore_none: false) { company.clients_of_firm.new("name" => "Another Client") }
assert !company.clients_of_firm.loaded?
assert_equal "Another Client", new_client.name
assert !new_client.persisted?
assert_equal new_client, company.clients_of_firm.last
end
def test_build
company = companies(:first_firm)
new_client = assert_no_queries(ignore_none: false) { company.clients_of_firm.build("name" => "Another Client") }
assert !company.clients_of_firm.loaded?
assert_equal "Another Client", new_client.name
assert !new_client.persisted?
assert_equal new_client, company.clients_of_firm.last
end
def test_collection_size_after_building
company = companies(:first_firm) # company already has one client
company.clients_of_firm.build("name" => "Another Client")
company.clients_of_firm.build("name" => "Yet Another Client")
assert_equal 4, company.clients_of_firm.size
assert_equal 4, company.clients_of_firm.uniq.size
end
def test_collection_not_empty_after_building
company = companies(:first_firm)
assert_predicate company.contracts, :empty?
company.contracts.build
assert_not_predicate company.contracts, :empty?
end
def test_collection_size_twice_for_regressions
post = posts(:thinking)
assert_equal 0, post.readers.size
# This test needs a post that has no readers, we assert it to ensure it holds,
# but need to reload the post because the very call to #size hides the bug.
post.reload
post.readers.build
size1 = post.readers.size
size2 = post.readers.size
assert_equal size1, size2
end
def test_build_many
company = companies(:first_firm)
new_clients = assert_no_queries(ignore_none: false) { company.clients_of_firm.build([{ "name" => "Another Client" }, { "name" => "Another Client II" }]) }
assert_equal 2, new_clients.size
end
def test_build_followed_by_save_does_not_load_target
companies(:first_firm).clients_of_firm.build("name" => "Another Client")
assert companies(:first_firm).save
assert !companies(:first_firm).clients_of_firm.loaded?
end
def test_build_without_loading_association
first_topic = topics(:first)
Reply.column_names
assert_equal 1, first_topic.replies.length
assert_no_queries do
first_topic.replies.build(title: "Not saved", content: "Superstars")
assert_equal 2, first_topic.replies.size
end
assert_equal 2, first_topic.replies.to_ary.size
end
def test_build_via_block
company = companies(:first_firm)
new_client = assert_no_queries(ignore_none: false) { company.clients_of_firm.build { |client| client.name = "Another Client" } }
assert !company.clients_of_firm.loaded?
assert_equal "Another Client", new_client.name
assert !new_client.persisted?
assert_equal new_client, company.clients_of_firm.last
end
def test_build_many_via_block
company = companies(:first_firm)
new_clients = assert_no_queries(ignore_none: false) do
company.clients_of_firm.build([{ "name" => "Another Client" }, { "name" => "Another Client II" }]) do |client|
client.name = "changed"
end
end
assert_equal 2, new_clients.size
assert_equal "changed", new_clients.first.name
assert_equal "changed", new_clients.last.name
end
def test_create_without_loading_association
first_firm = companies(:first_firm)
Firm.column_names
Client.column_names
assert_equal 2, first_firm.clients_of_firm.size
first_firm.clients_of_firm.reset
assert_queries(1) do
first_firm.clients_of_firm.create(name: "Superstars")
end
assert_equal 3, first_firm.clients_of_firm.size
end
def test_create
force_signal37_to_load_all_clients_of_firm
assert_predicate companies(:first_firm).clients_of_firm, :loaded?
new_client = companies(:first_firm).clients_of_firm.create("name" => "Another Client")
assert new_client.persisted?
assert_equal new_client, companies(:first_firm).clients_of_firm.last
assert_equal new_client, companies(:first_firm).clients_of_firm.reload.last
end
def test_create_many
companies(:first_firm).clients_of_firm.create([{ "name" => "Another Client" }, { "name" => "Another Client II" }])
assert_equal 4, companies(:first_firm).clients_of_firm.reload.size
end
def test_create_followed_by_save_does_not_load_target
companies(:first_firm).clients_of_firm.create("name" => "Another Client")
assert companies(:first_firm).save
assert !companies(:first_firm).clients_of_firm.loaded?
end
def test_deleting
force_signal37_to_load_all_clients_of_firm
assert_predicate companies(:first_firm).clients_of_firm, :loaded?
companies(:first_firm).clients_of_firm.delete(companies(:first_firm).clients_of_firm.first)
assert_equal 1, companies(:first_firm).clients_of_firm.size
assert_equal 1, companies(:first_firm).clients_of_firm.reload.size
end
def test_deleting_before_save
new_firm = Firm.new("name" => "A New Firm, Inc.")
new_client = new_firm.clients_of_firm.build("name" => "Another Client")
assert_equal 1, new_firm.clients_of_firm.size
new_firm.clients_of_firm.delete(new_client)
assert_equal 0, new_firm.clients_of_firm.size
end
def test_has_many_without_counter_cache_option
# Ship has a conventionally named `treasures_count` column, but the counter_cache
# option is not given on the association.
ship = Ship.create(name: "Countless", treasures_count: 10)
assert_not Ship.reflect_on_association(:treasures).has_cached_counter?
# Count should come from sql count() of treasures rather than treasures_count attribute
assert_equal ship.treasures.size, 0
assert_no_difference lambda { ship.reload.treasures_count }, "treasures_count should not be changed" do
ship.treasures.create(name: "Gold")
end
assert_no_difference lambda { ship.reload.treasures_count }, "treasures_count should not be changed" do
ship.treasures.destroy_all
end
end
def test_deleting_updates_counter_cache
topic = Topic.order("id ASC").first
assert_equal topic.replies.to_a.size, topic.replies_count
topic.replies.delete(topic.replies.first)
topic.reload
assert_equal topic.replies.to_a.size, topic.replies_count
end
def test_counter_cache_updates_in_memory_after_concat
topic = Topic.create title: "Zoom-zoom-zoom"
topic.replies << Reply.create(title: "re: zoom", content: "speedy quick!")
assert_equal 1, topic.replies_count
assert_equal 1, topic.replies.size
assert_equal 1, topic.reload.replies.size
end
def test_counter_cache_updates_in_memory_after_create
topic = Topic.create title: "Zoom-zoom-zoom"
topic.replies.create!(title: "re: zoom", content: "speedy quick!")
assert_equal 1, topic.replies_count
assert_equal 1, topic.replies.size
assert_equal 1, topic.reload.replies.size
end
def test_counter_cache_updates_in_memory_after_create_with_array
topic = Topic.create title: "Zoom-zoom-zoom"
topic.replies.create!([
{ title: "re: zoom", content: "speedy quick!" },
{ title: "re: zoom 2", content: "OMG lol!" },
])
assert_equal 2, topic.replies_count
assert_equal 2, topic.replies.size
assert_equal 2, topic.reload.replies.size
end
def test_pushing_association_updates_counter_cache
topic = Topic.order("id ASC").first
reply = Reply.create!
assert_difference "topic.reload.replies_count", 1 do
topic.replies << reply
end
end
def test_deleting_updates_counter_cache_without_dependent_option
post = posts(:welcome)
assert_difference "post.reload.tags_count", -1 do
post.taggings.delete(post.taggings.first)
end
end
def test_deleting_updates_counter_cache_with_dependent_delete_all
post = posts(:welcome)
post.update_columns(taggings_with_delete_all_count: post.tags_count)
assert_difference "post.reload.taggings_with_delete_all_count", -1 do
post.taggings_with_delete_all.delete(post.taggings_with_delete_all.first)
end
end
def test_deleting_updates_counter_cache_with_dependent_destroy
post = posts(:welcome)
post.update_columns(taggings_with_destroy_count: post.tags_count)
assert_difference "post.reload.taggings_with_destroy_count", -1 do
post.taggings_with_destroy.delete(post.taggings_with_destroy.first)
end
end
def test_calling_empty_with_counter_cache
post = posts(:welcome)
assert_queries(0) do
assert_not post.comments.empty?
end
end
def test_custom_named_counter_cache
topic = topics(:first)
assert_difference "topic.reload.replies_count", -1 do
topic.approved_replies.clear
end
end
def test_calling_update_attributes_on_id_changes_the_counter_cache
topic = Topic.order("id ASC").first
original_count = topic.replies.to_a.size
assert_equal original_count, topic.replies_count
first_reply = topic.replies.first
first_reply.update_attributes(parent_id: nil)
assert_equal original_count - 1, topic.reload.replies_count
first_reply.update_attributes(parent_id: topic.id)
assert_equal original_count, topic.reload.replies_count
end
def test_calling_update_attributes_changing_ids_doesnt_change_counter_cache
topic1 = Topic.find(1)
topic2 = Topic.find(3)
original_count1 = topic1.replies.to_a.size
original_count2 = topic2.replies.to_a.size
reply1 = topic1.replies.first
reply2 = topic2.replies.first
reply1.update_attributes(parent_id: topic2.id)
assert_equal original_count1 - 1, topic1.reload.replies_count
assert_equal original_count2 + 1, topic2.reload.replies_count
reply2.update_attributes(parent_id: topic1.id)
assert_equal original_count1, topic1.reload.replies_count
assert_equal original_count2, topic2.reload.replies_count
end
def test_deleting_a_collection
force_signal37_to_load_all_clients_of_firm
assert_predicate companies(:first_firm).clients_of_firm, :loaded?
companies(:first_firm).clients_of_firm.create("name" => "Another Client")
assert_equal 3, companies(:first_firm).clients_of_firm.size
companies(:first_firm).clients_of_firm.delete([companies(:first_firm).clients_of_firm[0], companies(:first_firm).clients_of_firm[1], companies(:first_firm).clients_of_firm[2]])
assert_equal 0, companies(:first_firm).clients_of_firm.size
assert_equal 0, companies(:first_firm).clients_of_firm.reload.size
end
def test_delete_all
force_signal37_to_load_all_clients_of_firm
assert_predicate companies(:first_firm).clients_of_firm, :loaded?
companies(:first_firm).dependent_clients_of_firm.create("name" => "Another Client")
clients = companies(:first_firm).dependent_clients_of_firm.to_a
assert_equal 3, clients.count
assert_difference "Client.count", -(clients.count) do
companies(:first_firm).dependent_clients_of_firm.delete_all
end
end
def test_delete_all_with_not_yet_loaded_association_collection
force_signal37_to_load_all_clients_of_firm
assert_predicate companies(:first_firm).clients_of_firm, :loaded?
companies(:first_firm).clients_of_firm.create("name" => "Another Client")
assert_equal 3, companies(:first_firm).clients_of_firm.size
companies(:first_firm).clients_of_firm.reset
companies(:first_firm).clients_of_firm.delete_all
assert_equal 0, companies(:first_firm).clients_of_firm.size
assert_equal 0, companies(:first_firm).clients_of_firm.reload.size
end
def test_transaction_when_deleting_persisted
good = Client.new(name: "Good")
bad = Client.new(name: "Bad", raise_on_destroy: true)
companies(:first_firm).clients_of_firm = [good, bad]
begin
companies(:first_firm).clients_of_firm.destroy(good, bad)
rescue Client::RaisedOnDestroy
end
assert_equal [good, bad], companies(:first_firm).clients_of_firm.reload
end
def test_transaction_when_deleting_new_record
assert_no_queries(ignore_none: false) do
firm = Firm.new
client = Client.new("name" => "New Client")
firm.clients_of_firm << client
firm.clients_of_firm.destroy(client)
end
end
def test_clearing_an_association_collection
firm = companies(:first_firm)
client_id = firm.clients_of_firm.first.id
assert_equal 2, firm.clients_of_firm.size
firm.clients_of_firm.clear
assert_equal 0, firm.clients_of_firm.size
assert_equal 0, firm.clients_of_firm.reload.size
assert_equal [], Client.destroyed_client_ids[firm.id]
# Should not be destroyed since the association is not dependent.
assert_nothing_raised do
assert_nil Client.find(client_id).firm
end
end
def test_clearing_updates_counter_cache
topic = Topic.first
assert_difference "topic.reload.replies_count", -1 do
topic.replies.clear
end
end
def test_clearing_updates_counter_cache_when_inverse_counter_cache_is_a_symbol_with_dependent_destroy
car = Car.first
car.engines.create!
assert_difference "car.reload.engines_count", -1 do
car.engines.clear
end
end
def test_clearing_a_dependent_association_collection
firm = companies(:first_firm)
client_id = firm.dependent_clients_of_firm.first.id
assert_equal 2, firm.dependent_clients_of_firm.size
assert_equal 1, Client.find_by_id(client_id).client_of
# :delete_all is called on each client since the dependent options is :destroy
firm.dependent_clients_of_firm.clear
assert_equal 0, firm.dependent_clients_of_firm.size
assert_equal 0, firm.dependent_clients_of_firm.reload.size
assert_equal [], Client.destroyed_client_ids[firm.id]
# Should be destroyed since the association is dependent.
assert_nil Client.find_by_id(client_id)
end
def test_delete_all_with_option_delete_all
firm = companies(:first_firm)
client_id = firm.dependent_clients_of_firm.first.id
firm.dependent_clients_of_firm.delete_all(:delete_all)
assert_nil Client.find_by_id(client_id)
end
def test_delete_all_accepts_limited_parameters
firm = companies(:first_firm)
assert_raise(ArgumentError) do
firm.dependent_clients_of_firm.delete_all(:destroy)
end
end
def test_clearing_an_exclusively_dependent_association_collection
firm = companies(:first_firm)
client_id = firm.exclusively_dependent_clients_of_firm.first.id
assert_equal 2, firm.exclusively_dependent_clients_of_firm.size
assert_equal [], Client.destroyed_client_ids[firm.id]
# :exclusively_dependent means each client is deleted directly from
# the database without looping through them calling destroy.
firm.exclusively_dependent_clients_of_firm.clear
assert_equal 0, firm.exclusively_dependent_clients_of_firm.size
assert_equal 0, firm.exclusively_dependent_clients_of_firm.reload.size
# no destroy-filters should have been called
assert_equal [], Client.destroyed_client_ids[firm.id]
# Should be destroyed since the association is exclusively dependent.
assert_nil Client.find_by_id(client_id)
end
def test_dependent_association_respects_optional_conditions_on_delete
firm = companies(:odegy)
Client.create(client_of: firm.id, name: "BigShot Inc.")
Client.create(client_of: firm.id, name: "SmallTime Inc.")
# only one of two clients is included in the association due to the :conditions key
assert_equal 2, Client.where(client_of: firm.id).size
assert_equal 1, firm.dependent_conditional_clients_of_firm.size
firm.destroy
# only the correctly associated client should have been deleted
assert_equal 1, Client.where(client_of: firm.id).size
end
def test_dependent_association_respects_optional_sanitized_conditions_on_delete
firm = companies(:odegy)
Client.create(client_of: firm.id, name: "BigShot Inc.")
Client.create(client_of: firm.id, name: "SmallTime Inc.")
# only one of two clients is included in the association due to the :conditions key
assert_equal 2, Client.where(client_of: firm.id).size
assert_equal 1, firm.dependent_sanitized_conditional_clients_of_firm.size
firm.destroy
# only the correctly associated client should have been deleted
assert_equal 1, Client.where(client_of: firm.id).size
end
def test_dependent_association_respects_optional_hash_conditions_on_delete
firm = companies(:odegy)
Client.create(client_of: firm.id, name: "BigShot Inc.")
Client.create(client_of: firm.id, name: "SmallTime Inc.")
# only one of two clients is included in the association due to the :conditions key
assert_equal 2, Client.where(client_of: firm.id).size
assert_equal 1, firm.dependent_sanitized_conditional_clients_of_firm.size
firm.destroy
# only the correctly associated client should have been deleted
assert_equal 1, Client.where(client_of: firm.id).size
end
def test_delete_all_association_with_primary_key_deletes_correct_records
firm = Firm.first
# break the vanilla firm_id foreign key
assert_equal 3, firm.clients.count
firm.clients.first.update_columns(firm_id: nil)
assert_equal 2, firm.clients.reload.count
assert_equal 2, firm.clients_using_primary_key_with_delete_all.count
old_record = firm.clients_using_primary_key_with_delete_all.first
firm = Firm.first
firm.destroy
assert_nil Client.find_by_id(old_record.id)
end
def test_creation_respects_hash_condition
ms_client = companies(:first_firm).clients_like_ms_with_hash_conditions.build
assert ms_client.save
assert_equal "Microsoft", ms_client.name
another_ms_client = companies(:first_firm).clients_like_ms_with_hash_conditions.create
assert another_ms_client.persisted?
assert_equal "Microsoft", another_ms_client.name
end
def test_clearing_without_initial_access
firm = companies(:first_firm)
firm.clients_of_firm.clear
assert_equal 0, firm.clients_of_firm.size
assert_equal 0, firm.clients_of_firm.reload.size
end
def test_deleting_a_item_which_is_not_in_the_collection
force_signal37_to_load_all_clients_of_firm
assert_predicate companies(:first_firm).clients_of_firm, :loaded?
summit = Client.find_by_name("Summit")
companies(:first_firm).clients_of_firm.delete(summit)
assert_equal 2, companies(:first_firm).clients_of_firm.size
assert_equal 2, companies(:first_firm).clients_of_firm.reload.size
assert_equal 2, summit.client_of
end
def test_deleting_by_integer_id
david = Developer.find(1)
assert_difference "david.projects.count", -1 do
assert_equal 1, david.projects.delete(1).size
end
assert_equal 1, david.projects.size
end
def test_deleting_by_string_id
david = Developer.find(1)
assert_difference "david.projects.count", -1 do
assert_equal 1, david.projects.delete("1").size
end
assert_equal 1, david.projects.size
end
def test_deleting_self_type_mismatch
david = Developer.find(1)
david.projects.reload
assert_raise(ActiveRecord::AssociationTypeMismatch) { david.projects.delete(Project.find(1).developers) }
end
def test_destroying
force_signal37_to_load_all_clients_of_firm
assert_predicate companies(:first_firm).clients_of_firm, :loaded?
assert_difference "Client.count", -1 do
companies(:first_firm).clients_of_firm.destroy(companies(:first_firm).clients_of_firm.first)
end
assert_equal 1, companies(:first_firm).reload.clients_of_firm.size
assert_equal 1, companies(:first_firm).clients_of_firm.reload.size
end
def test_destroying_by_integer_id
force_signal37_to_load_all_clients_of_firm
assert_predicate companies(:first_firm).clients_of_firm, :loaded?
assert_difference "Client.count", -1 do
companies(:first_firm).clients_of_firm.destroy(companies(:first_firm).clients_of_firm.first.id)
end
assert_equal 1, companies(:first_firm).reload.clients_of_firm.size
assert_equal 1, companies(:first_firm).clients_of_firm.reload.size
end
def test_destroying_by_string_id
force_signal37_to_load_all_clients_of_firm
assert_predicate companies(:first_firm).clients_of_firm, :loaded?
assert_difference "Client.count", -1 do
companies(:first_firm).clients_of_firm.destroy(companies(:first_firm).clients_of_firm.first.id.to_s)
end
assert_equal 1, companies(:first_firm).reload.clients_of_firm.size
assert_equal 1, companies(:first_firm).clients_of_firm.reload.size
end
def test_destroying_a_collection
force_signal37_to_load_all_clients_of_firm
assert_predicate companies(:first_firm).clients_of_firm, :loaded?
companies(:first_firm).clients_of_firm.create("name" => "Another Client")
assert_equal 3, companies(:first_firm).clients_of_firm.size
assert_difference "Client.count", -2 do
companies(:first_firm).clients_of_firm.destroy([companies(:first_firm).clients_of_firm[0], companies(:first_firm).clients_of_firm[1]])
end
assert_equal 1, companies(:first_firm).reload.clients_of_firm.size
assert_equal 1, companies(:first_firm).clients_of_firm.reload.size
end
def test_destroy_all
force_signal37_to_load_all_clients_of_firm
assert_predicate companies(:first_firm).clients_of_firm, :loaded?
clients = companies(:first_firm).clients_of_firm.to_a
assert !clients.empty?, "37signals has clients after load"
destroyed = companies(:first_firm).clients_of_firm.destroy_all
assert_equal clients.sort_by(&:id), destroyed.sort_by(&:id)
assert destroyed.all?(&:frozen?), "destroyed clients should be frozen"
assert companies(:first_firm).clients_of_firm.empty?, "37signals has no clients after destroy all"
assert companies(:first_firm).clients_of_firm.reload.empty?, "37signals has no clients after destroy all and refresh"
end
def test_dependence
firm = companies(:first_firm)
assert_equal 3, firm.clients.size
firm.destroy
assert Client.all.merge!(where: "firm_id=#{firm.id}").to_a.empty?
end
def test_dependence_for_associations_with_hash_condition
david = authors(:david)
assert_difference("Post.count", -1) { assert david.destroy }
end
def test_destroy_dependent_when_deleted_from_association
# sometimes tests on Oracle fail if ORDER BY is not provided therefore add always :order with :first
firm = Firm.all.merge!(order: "id").first
assert_equal 3, firm.clients.size
client = firm.clients.first
firm.clients.delete(client)
assert_raise(ActiveRecord::RecordNotFound) { Client.find(client.id) }
assert_raise(ActiveRecord::RecordNotFound) { firm.clients.find(client.id) }
assert_equal 2, firm.clients.size
end
def test_three_levels_of_dependence
topic = Topic.create "title" => "neat and simple"
reply = topic.replies.create "title" => "neat and simple", "content" => "still digging it"
reply.replies.create "title" => "neat and simple", "content" => "ain't complaining"
assert_nothing_raised { topic.destroy }
end
def test_dependence_with_transaction_support_on_failure
firm = companies(:first_firm)
clients = firm.clients
assert_equal 3, clients.length
clients.last.instance_eval { def overwrite_to_raise() raise "Trigger rollback" end }
firm.destroy rescue "do nothing"
assert_equal 3, Client.all.merge!(where: "firm_id=#{firm.id}").to_a.size
end
def test_dependence_on_account
num_accounts = Account.count
companies(:first_firm).destroy
assert_equal num_accounts - 1, Account.count
end
def test_depends_and_nullify
num_accounts = Account.count
core = companies(:rails_core)
assert_equal accounts(:rails_core_account), core.account
assert_equal companies(:leetsoft, :jadedpixel), core.companies
core.destroy
assert_nil accounts(:rails_core_account).reload.firm_id
assert_nil companies(:leetsoft).reload.client_of
assert_nil companies(:jadedpixel).reload.client_of
assert_equal num_accounts, Account.count
end
def test_restrict_with_exception
firm = RestrictedWithExceptionFirm.create!(name: "restrict")
firm.companies.create(name: "child")
assert !firm.companies.empty?
assert_raise(ActiveRecord::DeleteRestrictionError) { firm.destroy }
assert RestrictedWithExceptionFirm.exists?(name: "restrict")
assert firm.companies.exists?(name: "child")
end
def test_restrict_with_error
firm = RestrictedWithErrorFirm.create!(name: "restrict")
firm.companies.create(name: "child")
assert !firm.companies.empty?
firm.destroy
assert !firm.errors.empty?
assert_equal "Cannot delete record because dependent companies exist", firm.errors[:base].first
assert RestrictedWithErrorFirm.exists?(name: "restrict")
assert firm.companies.exists?(name: "child")
end
def test_restrict_with_error_with_locale
I18n.backend = I18n::Backend::Simple.new
I18n.backend.store_translations "en", activerecord: { attributes: { restricted_with_error_firm: { companies: "client companies" } } }
firm = RestrictedWithErrorFirm.create!(name: "restrict")
firm.companies.create(name: "child")
assert !firm.companies.empty?
firm.destroy
assert !firm.errors.empty?
assert_equal "Cannot delete record because dependent client companies exist", firm.errors[:base].first
assert RestrictedWithErrorFirm.exists?(name: "restrict")
assert firm.companies.exists?(name: "child")
ensure
I18n.backend.reload!
end
def test_included_in_collection
assert_equal true, companies(:first_firm).clients.include?(Client.find(2))
end
def test_included_in_collection_for_new_records
client = Client.create(name: "Persisted")
assert_nil client.client_of
assert_equal false, Firm.new.clients_of_firm.include?(client),
"includes a client that does not belong to any firm"
end
def test_adding_array_and_collection
assert_nothing_raised { Firm.first.clients + Firm.all.last.clients }
end
def test_replace_with_less
firm = Firm.all.merge!(order: "id").first
firm.clients = [companies(:first_client)]
assert firm.save, "Could not save firm"
firm.reload
assert_equal 1, firm.clients.length
end
def test_replace_with_less_and_dependent_nullify
num_companies = Company.count
companies(:rails_core).companies = []
assert_equal num_companies, Company.count
end
def test_replace_with_new
firm = Firm.all.merge!(order: "id").first
firm.clients = [companies(:second_client), Client.new("name" => "New Client")]
firm.save
firm.reload
assert_equal 2, firm.clients.length
assert_equal false, firm.clients.include?(:first_client)
end
def test_replace_failure
firm = companies(:first_firm)
account = Account.new
orig_accounts = firm.accounts.to_a
assert !account.valid?
assert !orig_accounts.empty?
error = assert_raise ActiveRecord::RecordNotSaved do
firm.accounts = [account]
end
assert_equal orig_accounts, firm.accounts
assert_equal "Failed to replace accounts because one or more of the " \
"new records could not be saved.", error.message
end
def test_replace_with_same_content
firm = Firm.first
firm.clients = []
firm.save
assert_queries(0, ignore_none: true) do
firm.clients = []
end
assert_equal [], firm.send("clients=", [])
end
def test_transactions_when_replacing_on_persisted
good = Client.new(name: "Good")
bad = Client.new(name: "Bad", raise_on_save: true)
companies(:first_firm).clients_of_firm = [good]
begin
companies(:first_firm).clients_of_firm = [bad]
rescue Client::RaisedOnSave
end
assert_equal [good], companies(:first_firm).clients_of_firm.reload
end
def test_transactions_when_replacing_on_new_record
assert_no_queries(ignore_none: false) do
firm = Firm.new
firm.clients_of_firm = [Client.new("name" => "New Client")]
end
end
def test_get_ids
assert_equal [companies(:first_client).id, companies(:second_client).id, companies(:another_first_firm_client).id], companies(:first_firm).client_ids
end
def test_get_ids_for_loaded_associations
company = companies(:first_firm)
company.clients.reload
assert_queries(0) do
company.client_ids
company.client_ids
end
end
def test_get_ids_for_unloaded_associations_does_not_load_them
company = companies(:first_firm)
assert !company.clients.loaded?
assert_equal [companies(:first_client).id, companies(:second_client).id, companies(:another_first_firm_client).id], company.client_ids
assert !company.clients.loaded?
end
def test_counter_cache_on_unloaded_association
car = Car.create(name: "My AppliCar")
assert_equal car.engines.size, 0
end
def test_get_ids_ignores_include_option
assert_equal [readers(:michael_welcome).id], posts(:welcome).readers_with_person_ids
end
def test_get_ids_for_ordered_association
assert_equal [companies(:another_first_firm_client).id, companies(:second_client).id, companies(:first_client).id], companies(:first_firm).clients_ordered_by_name_ids
end
def test_get_ids_for_association_on_new_record_does_not_try_to_find_records
Company.columns # Load schema information so we don't query below
Contract.columns # if running just this test.
company = Company.new
assert_queries(0) do
company.contract_ids
end
assert_equal [], company.contract_ids
end
def test_set_ids_for_association_on_new_record_applies_association_correctly
contract_a = Contract.create!
contract_b = Contract.create!
Contract.create! # another contract
company = Company.new(name: "Some Company")
company.contract_ids = [contract_a.id, contract_b.id]
assert_equal [contract_a.id, contract_b.id], company.contract_ids
assert_equal [contract_a, contract_b], company.contracts
company.save!
assert_equal company, contract_a.reload.company
assert_equal company, contract_b.reload.company
end
def test_assign_ids_ignoring_blanks
firm = Firm.create!(name: "Apple")
firm.client_ids = [companies(:first_client).id, nil, companies(:second_client).id, ""]
firm.save!
assert_equal 2, firm.clients.reload.size
assert_equal true, firm.clients.include?(companies(:second_client))
end
def test_get_ids_for_through
assert_equal [comments(:eager_other_comment1).id], authors(:mary).comment_ids
end
def test_modifying_a_through_a_has_many_should_raise
[
lambda { authors(:mary).comment_ids = [comments(:greetings).id, comments(:more_greetings).id] },
lambda { authors(:mary).comments = [comments(:greetings), comments(:more_greetings)] },
lambda { authors(:mary).comments << Comment.create!(body: "Yay", post_id: 424242) },
lambda { authors(:mary).comments.delete(authors(:mary).comments.first) },
].each { |block| assert_raise(ActiveRecord::HasManyThroughCantAssociateThroughHasOneOrManyReflection, &block) }
end
def test_dynamic_find_should_respect_association_order_for_through
assert_equal Comment.find(10), authors(:david).comments_desc.where("comments.type = 'SpecialComment'").first
assert_equal Comment.find(10), authors(:david).comments_desc.find_by_type("SpecialComment")
end
def test_has_many_through_respects_hash_conditions
assert_equal authors(:david).hello_posts, authors(:david).hello_posts_with_hash_conditions
assert_equal authors(:david).hello_post_comments, authors(:david).hello_post_comments_with_hash_conditions
end
def test_include_uses_array_include_after_loaded
firm = companies(:first_firm)
firm.clients.load_target
client = firm.clients.first
assert_no_queries do
assert firm.clients.loaded?
assert_equal true, firm.clients.include?(client)
end
end
def test_include_checks_if_record_exists_if_target_not_loaded
firm = companies(:first_firm)
client = firm.clients.first
firm.reload
assert ! firm.clients.loaded?
assert_queries(1) do
assert_equal true, firm.clients.include?(client)
end
assert ! firm.clients.loaded?
end
def test_include_returns_false_for_non_matching_record_to_verify_scoping
firm = companies(:first_firm)
client = Client.create!(name: "Not Associated")
assert ! firm.clients.loaded?
assert_equal false, firm.clients.include?(client)
end
def test_calling_first_nth_or_last_on_association_should_not_load_association
firm = companies(:first_firm)
firm.clients.first
firm.clients.second
firm.clients.last
assert !firm.clients.loaded?
end
def test_calling_first_or_last_on_loaded_association_should_not_fetch_with_query
firm = companies(:first_firm)
firm.clients.load_target
assert firm.clients.loaded?
assert_no_queries(ignore_none: false) do
firm.clients.first
assert_equal 2, firm.clients.first(2).size
firm.clients.last
assert_equal 2, firm.clients.last(2).size
end
end
def test_calling_first_or_last_on_existing_record_with_build_should_load_association
firm = companies(:first_firm)
firm.clients.build(name: "Foo")
assert !firm.clients.loaded?
assert_queries 1 do
firm.clients.first
firm.clients.second
firm.clients.last
end
assert firm.clients.loaded?
end
def test_calling_first_nth_or_last_on_existing_record_with_create_should_not_load_association
firm = companies(:first_firm)
firm.clients.create(name: "Foo")
assert !firm.clients.loaded?
assert_queries 3 do
firm.clients.first
firm.clients.second
firm.clients.last
end
assert !firm.clients.loaded?
end
def test_calling_first_nth_or_last_on_new_record_should_not_run_queries
firm = Firm.new
assert_no_queries do
firm.clients.first
firm.clients.second
firm.clients.last
end
end
def test_calling_first_or_last_with_integer_on_association_should_not_load_association
firm = companies(:first_firm)
firm.clients.create(name: "Foo")
assert !firm.clients.loaded?
assert_queries 2 do
firm.clients.first(2)
firm.clients.last(2)
end
assert !firm.clients.loaded?
end
def test_calling_many_should_count_instead_of_loading_association
firm = companies(:first_firm)
assert_queries(1) do
firm.clients.many? # use count query
end
assert !firm.clients.loaded?
end
def test_calling_many_on_loaded_association_should_not_use_query
firm = companies(:first_firm)
firm.clients.collect # force load
assert_no_queries { assert firm.clients.many? }
end
def test_calling_many_should_defer_to_collection_if_using_a_block
firm = companies(:first_firm)
assert_queries(1) do
firm.clients.expects(:size).never
firm.clients.many? { true }
end
assert firm.clients.loaded?
end
def test_calling_many_should_return_false_if_none_or_one
firm = companies(:another_firm)
assert !firm.clients_like_ms.many?
assert_equal 0, firm.clients_like_ms.size
firm = companies(:first_firm)
assert !firm.limited_clients.many?
assert_equal 1, firm.limited_clients.size
end
def test_calling_many_should_return_true_if_more_than_one
firm = companies(:first_firm)
assert firm.clients.many?
assert_equal 3, firm.clients.size
end
def test_calling_none_should_count_instead_of_loading_association
firm = companies(:first_firm)
assert_queries(1) do
firm.clients.none? # use count query
end
assert !firm.clients.loaded?
end
def test_calling_none_on_loaded_association_should_not_use_query
firm = companies(:first_firm)
firm.clients.collect # force load
assert_no_queries { assert ! firm.clients.none? }
end
def test_calling_none_should_defer_to_collection_if_using_a_block
firm = companies(:first_firm)
assert_queries(1) do
firm.clients.expects(:size).never
firm.clients.none? { true }
end
assert firm.clients.loaded?
end
def test_calling_none_should_return_true_if_none
firm = companies(:another_firm)
assert firm.clients_like_ms.none?
assert_equal 0, firm.clients_like_ms.size
end
def test_calling_none_should_return_false_if_any
firm = companies(:first_firm)
assert !firm.limited_clients.none?
assert_equal 1, firm.limited_clients.size
end
def test_calling_one_should_count_instead_of_loading_association
firm = companies(:first_firm)
assert_queries(1) do
firm.clients.one? # use count query
end
assert !firm.clients.loaded?
end
def test_calling_one_on_loaded_association_should_not_use_query
firm = companies(:first_firm)
firm.clients.collect # force load
assert_no_queries { assert ! firm.clients.one? }
end
def test_calling_one_should_defer_to_collection_if_using_a_block
firm = companies(:first_firm)
assert_queries(1) do
firm.clients.expects(:size).never
firm.clients.one? { true }
end
assert firm.clients.loaded?
end
def test_calling_one_should_return_false_if_zero
firm = companies(:another_firm)
assert ! firm.clients_like_ms.one?
assert_equal 0, firm.clients_like_ms.size
end
def test_calling_one_should_return_true_if_one
firm = companies(:first_firm)
assert firm.limited_clients.one?
assert_equal 1, firm.limited_clients.size
end
def test_calling_one_should_return_false_if_more_than_one
firm = companies(:first_firm)
assert ! firm.clients.one?
assert_equal 3, firm.clients.size
end
def test_joins_with_namespaced_model_should_use_correct_type
old = ActiveRecord::Base.store_full_sti_class
ActiveRecord::Base.store_full_sti_class = true
firm = Namespaced::Firm.create(name: "Some Company")
firm.clients.create(name: "Some Client")
stats = Namespaced::Firm.all.merge!(
select: "#{Namespaced::Firm.table_name}.id, COUNT(#{Namespaced::Client.table_name}.id) AS num_clients",
joins: :clients,
group: "#{Namespaced::Firm.table_name}.id"
).find firm.id
assert_equal 1, stats.num_clients.to_i
ensure
ActiveRecord::Base.store_full_sti_class = old
end
def test_association_proxy_transaction_method_starts_transaction_in_association_class
Comment.expects(:transaction)
Post.first.comments.transaction do
# nothing
end
end
def test_sending_new_to_association_proxy_should_have_same_effect_as_calling_new
client_association = companies(:first_firm).clients
assert_equal client_association.new.attributes, client_association.send(:new).attributes
end
def test_respond_to_private_class_methods
client_association = companies(:first_firm).clients
assert !client_association.respond_to?(:private_method)
assert client_association.respond_to?(:private_method, true)
end
def test_creating_using_primary_key
firm = Firm.all.merge!(order: "id").first
client = firm.clients_using_primary_key.create!(name: "test")
assert_equal firm.name, client.firm_name
end
def test_defining_has_many_association_with_delete_all_dependency_lazily_evaluates_target_class
ActiveRecord::Reflection::AssociationReflection.any_instance.expects(:class_name).never
class_eval(<<-EOF, __FILE__, __LINE__ + 1)
class DeleteAllModel < ActiveRecord::Base
has_many :nonentities, :dependent => :delete_all
end
EOF
end
def test_defining_has_many_association_with_nullify_dependency_lazily_evaluates_target_class
ActiveRecord::Reflection::AssociationReflection.any_instance.expects(:class_name).never
class_eval(<<-EOF, __FILE__, __LINE__ + 1)
class NullifyModel < ActiveRecord::Base
has_many :nonentities, :dependent => :nullify
end
EOF
end
def test_attributes_are_being_set_when_initialized_from_has_many_association_with_where_clause
new_comment = posts(:welcome).comments.where(body: "Some content").build
assert_equal new_comment.body, "Some content"
end
def test_attributes_are_being_set_when_initialized_from_has_many_association_with_multiple_where_clauses
new_comment = posts(:welcome).comments.where(body: "Some content").where(type: "SpecialComment").build
assert_equal new_comment.body, "Some content"
assert_equal new_comment.type, "SpecialComment"
assert_equal new_comment.post_id, posts(:welcome).id
end
def test_include_method_in_has_many_association_should_return_true_for_instance_added_with_build
post = Post.new
comment = post.comments.build
assert_equal true, post.comments.include?(comment)
end
def test_load_target_respects_protected_attributes
topic = Topic.create!
reply = topic.replies.create(title: "reply 1")
reply.approved = false
reply.save!
# Save with a different object instance, so the instance that's still held
# in topic.relies doesn't know about the changed attribute.
reply2 = Reply.find(reply.id)
reply2.approved = true
reply2.save!
# Force loading the collection from the db. This will merge the existing
# object (reply) with what gets loaded from the db (which includes the
# changed approved attribute). approved is a protected attribute, so if mass
# assignment is used, it won't get updated and will still be false.
first = topic.replies.to_a.first
assert_equal reply.id, first.id
assert_equal true, first.approved?
end
def test_to_a_should_dup_target
ary = topics(:first).replies.to_a
target = topics(:first).replies.target
assert_not_equal target.object_id, ary.object_id
end
def test_merging_with_custom_attribute_writer
bulb = Bulb.new(color: "red")
assert_equal "RED!", bulb.color
car = Car.create!
car.bulbs << bulb
assert_equal "RED!", car.bulbs.to_a.first.color
end
def test_abstract_class_with_polymorphic_has_many
post = SubStiPost.create! title: "fooo", body: "baa"
tagging = Tagging.create! taggable: post
assert_equal [tagging], post.taggings
end
def test_with_polymorphic_has_many_with_custom_columns_name
post = Post.create! title: "foo", body: "bar"
image = Image.create!
post.images << image
assert_equal [image], post.images
end
def test_build_with_polymorphic_has_many_does_not_allow_to_override_type_and_id
welcome = posts(:welcome)
tagging = welcome.taggings.build(taggable_id: 99, taggable_type: "ShouldNotChange")
assert_equal welcome.id, tagging.taggable_id
assert_equal "Post", tagging.taggable_type
end
def test_dont_call_save_callbacks_twice_on_has_many
firm = companies(:first_firm)
contract = firm.contracts.create!
assert_equal 1, contract.hi_count
assert_equal 1, contract.bye_count
end
def test_association_attributes_are_available_to_after_initialize
car = Car.create(name: "honda")
bulb = car.bulbs.build
assert_equal car.id, bulb.attributes_after_initialize["car_id"]
end
def test_attributes_are_set_when_initialized_from_has_many_null_relationship
car = Car.new name: "honda"
bulb = car.bulbs.where(name: "headlight").first_or_initialize
assert_equal "headlight", bulb.name
end
def test_attributes_are_set_when_initialized_from_polymorphic_has_many_null_relationship
post = Post.new title: "title", body: "bar"
tag = Tag.create!(name: "foo")
tagging = post.taggings.where(tag: tag).first_or_initialize
assert_equal tag.id, tagging.tag_id
assert_equal "Post", tagging.taggable_type
end
def test_replace
car = Car.create(name: "honda")
bulb1 = car.bulbs.create
bulb2 = Bulb.create
assert_equal [bulb1], car.bulbs
car.bulbs.replace([bulb2])
assert_equal [bulb2], car.bulbs
assert_equal [bulb2], car.reload.bulbs
end
def test_replace_returns_target
car = Car.create(name: "honda")
bulb1 = car.bulbs.create
bulb2 = car.bulbs.create
bulb3 = Bulb.create
assert_equal [bulb1, bulb2], car.bulbs
result = car.bulbs.replace([bulb3, bulb1])
assert_equal [bulb1, bulb3], car.bulbs
assert_equal [bulb1, bulb3], result
end
def test_collection_association_with_private_kernel_method
firm = companies(:first_firm)
assert_equal [accounts(:signals37)], firm.accounts.open
end
test "first_or_initialize adds the record to the association" do
firm = Firm.create! name: "omg"
client = firm.clients_of_firm.first_or_initialize
assert_equal [client], firm.clients_of_firm
end
test "first_or_create adds the record to the association" do
firm = Firm.create! name: "omg"
firm.clients_of_firm.load_target
client = firm.clients_of_firm.first_or_create name: "lol"
assert_equal [client], firm.clients_of_firm
assert_equal [client], firm.reload.clients_of_firm
end
test "delete_all, when not loaded, doesn't load the records" do
post = posts(:welcome)
assert post.taggings_with_delete_all.count > 0
assert !post.taggings_with_delete_all.loaded?
# 2 queries: one DELETE and another to update the counter cache
assert_queries(2) do
post.taggings_with_delete_all.delete_all
end
end
test "has many associations on new records use null relations" do
post = Post.new
assert_no_queries(ignore_none: false) do
assert_equal [], post.comments
assert_equal [], post.comments.where(body: "omg")
assert_equal [], post.comments.pluck(:body)
assert_equal 0, post.comments.sum(:id)
assert_equal 0, post.comments.count
end
end
test "collection proxy respects default scope" do
author = authors(:mary)
assert !author.first_posts.exists?
end
test "association with extend option" do
post = posts(:welcome)
assert_equal "lifo", post.comments_with_extend.author
assert_equal "hello", post.comments_with_extend.greeting
end
test "association with extend option with multiple extensions" do
post = posts(:welcome)
assert_equal "lifo", post.comments_with_extend_2.author
assert_equal "hello", post.comments_with_extend_2.greeting
end
test "delete record with complex joins" do
david = authors(:david)
post = david.posts.first
post.type = "PostWithSpecialCategorization"
post.save
categorization = post.categorizations.first
categorization.special = true
categorization.save
assert_not_equal [], david.posts_with_special_categorizations
david.posts_with_special_categorizations = []
assert_equal [], david.posts_with_special_categorizations
end
test "does not duplicate associations when used with natural primary keys" do
speedometer = Speedometer.create!(id: "4")
speedometer.minivans.create!(minivan_id: "a-van-red" , name: "a van", color: "red")
assert_equal 1, speedometer.minivans.to_a.size, "Only one association should be present:\n#{speedometer.minivans.to_a}"
assert_equal 1, speedometer.reload.minivans.to_a.size
end
test "can unscope the default scope of the associated model" do
car = Car.create!
bulb1 = Bulb.create! name: "defaulty", car: car
bulb2 = Bulb.create! name: "other", car: car
assert_equal [bulb1], car.bulbs
assert_equal [bulb1, bulb2], car.all_bulbs.sort_by(&:id)
end
test "can unscope and where the default scope of the associated model" do
Car.has_many :other_bulbs, -> { unscope(where: [:name]).where(name: "other") }, class_name: "Bulb"
car = Car.create!
bulb1 = Bulb.create! name: "defaulty", car: car
bulb2 = Bulb.create! name: "other", car: car
assert_equal [bulb1], car.bulbs
assert_equal [bulb2], car.other_bulbs
end
test "can rewhere the default scope of the associated model" do
Car.has_many :old_bulbs, -> { rewhere(name: "old") }, class_name: "Bulb"
car = Car.create!
bulb1 = Bulb.create! name: "defaulty", car: car
bulb2 = Bulb.create! name: "old", car: car
assert_equal [bulb1], car.bulbs
assert_equal [bulb2], car.old_bulbs
end
test "unscopes the default scope of associated model when used with include" do
car = Car.create!
bulb = Bulb.create! name: "other", car: car
assert_equal bulb, Car.find(car.id).all_bulbs.first
assert_equal bulb, Car.includes(:all_bulbs).find(car.id).all_bulbs.first
end
test "raises RecordNotDestroyed when replaced child can't be destroyed" do
car = Car.create!
original_child = FailedBulb.create!(car: car)
error = assert_raise(ActiveRecord::RecordNotDestroyed) do
car.failed_bulbs = [FailedBulb.create!]
end
assert_equal [original_child], car.reload.failed_bulbs
assert_equal "Failed to destroy the record", error.message
end
test "updates counter cache when default scope is given" do
topic = DefaultRejectedTopic.create approved: true
assert_difference "topic.reload.replies_count", 1 do
topic.approved_replies.create!
end
end
test "dangerous association name raises ArgumentError" do
[:errors, "errors", :save, "save"].each do |name|
assert_raises(ArgumentError, "Association #{name} should not be allowed") do
Class.new(ActiveRecord::Base) do
has_many name
end
end
end
end
test "passes custom context validation to validate children" do
pirate = FamousPirate.new
pirate.famous_ships << ship = FamousShip.new
assert pirate.valid?
assert_not pirate.valid?(:conference)
assert_equal "can't be blank", ship.errors[:name].first
end
test "association with instance dependent scope" do
bob = authors(:bob)
Post.create!(title: "signed post by bob", body: "stuff", author: authors(:bob))
Post.create!(title: "anonymous post", body: "more stuff", author: authors(:bob))
assert_equal ["misc post by bob", "other post by bob",
"signed post by bob"], bob.posts_with_signature.map(&:title).sort
assert_equal [], authors(:david).posts_with_signature.map(&:title)
end
test "associations autosaves when object is already persisted" do
bulb = Bulb.create!
tyre = Tyre.create!
car = Car.create! do |c|
c.bulbs << bulb
c.tyres << tyre
end
assert_equal 1, car.bulbs.count
assert_equal 1, car.tyres.count
end
test "associations replace in memory when records have the same id" do
bulb = Bulb.create!
car = Car.create!(bulbs: [bulb])
new_bulb = Bulb.find(bulb.id)
new_bulb.name = "foo"
car.bulbs = [new_bulb]
assert_equal "foo", car.bulbs.first.name
end
test "in memory replacement executes no queries" do
bulb = Bulb.create!
car = Car.create!(bulbs: [bulb])
new_bulb = Bulb.find(bulb.id)
assert_no_queries do
car.bulbs = [new_bulb]
end
end
test "in memory replacements do not execute callbacks" do
raise_after_add = false
klass = Class.new(ActiveRecord::Base) do
self.table_name = :cars
has_many :bulbs, after_add: proc { raise if raise_after_add }
def self.name
"Car"
end
end
bulb = Bulb.create!
car = klass.create!(bulbs: [bulb])
new_bulb = Bulb.find(bulb.id)
raise_after_add = true
assert_nothing_raised do
car.bulbs = [new_bulb]
end
end
test "in memory replacements sets inverse instance" do
bulb = Bulb.create!
car = Car.create!(bulbs: [bulb])
new_bulb = Bulb.find(bulb.id)
car.bulbs = [new_bulb]
assert_same car, new_bulb.car
end
test "in memory replacement maintains order" do
first_bulb = Bulb.create!
second_bulb = Bulb.create!
car = Car.create!(bulbs: [first_bulb, second_bulb])
same_bulb = Bulb.find(first_bulb.id)
car.bulbs = [second_bulb, same_bulb]
assert_equal [first_bulb, second_bulb], car.bulbs
end
test "double insertion of new object to association when same association used in the after create callback of a new object" do
reset_callbacks(:save, Bulb) do
Bulb.after_save { |record| record.car.bulbs.load }
car = Car.create!
car.bulbs << Bulb.new
assert_equal 1, car.bulbs.size
end
end
class AuthorWithErrorDestroyingAssociation < ActiveRecord::Base
self.table_name = "authors"
has_many :posts_with_error_destroying,
class_name: "PostWithErrorDestroying",
foreign_key: :author_id,
dependent: :destroy
end
class PostWithErrorDestroying < ActiveRecord::Base
self.table_name = "posts"
self.inheritance_column = nil
before_destroy -> { throw :abort }
end
def test_destroy_does_not_raise_when_association_errors_on_destroy
assert_no_difference "AuthorWithErrorDestroyingAssociation.count" do
author = AuthorWithErrorDestroyingAssociation.first
assert_not author.destroy
end
end
def test_destroy_with_bang_bubbles_errors_from_associations
error = assert_raises ActiveRecord::RecordNotDestroyed do
AuthorWithErrorDestroyingAssociation.first.destroy!
end
assert_instance_of PostWithErrorDestroying, error.record
end
def test_ids_reader_memoization
car = Car.create!(name: "Tofaş")
bulb = Bulb.create!(car: car)
assert_equal [bulb.id], car.bulb_ids
assert_no_queries { car.bulb_ids }
end
def test_loading_association_in_validate_callback_doesnt_affect_persistence
reset_callbacks(:validation, Bulb) do
Bulb.after_validation { |m| m.car.bulbs.load }
car = Car.create!(name: "Car")
bulb = car.bulbs.create!
assert_equal [bulb], car.bulbs
end
end
private
def force_signal37_to_load_all_clients_of_firm
companies(:first_firm).clients_of_firm.load_target
end
def reset_callbacks(kind, klass)
old_callbacks = {}
old_callbacks[klass] = klass.send("_#{kind}_callbacks").dup
klass.subclasses.each do |subclass|
old_callbacks[subclass] = subclass.send("_#{kind}_callbacks").dup
end
yield
ensure
klass.send("_#{kind}_callbacks=", old_callbacks[klass])
klass.subclasses.each do |subclass|
subclass.send("_#{kind}_callbacks=", old_callbacks[subclass])
end
end
end
| 32.975416 | 180 | 0.744661 |
87a8fac852c82d0244c309a2421211c62e4308c0 | 1,443 | class FacebookPublisher < Facebooker::Rails::Publisher
helper PostsHelper, LocationsHelper, PicturesHelper, GeneralUtilities
# Defines the template for the feed item that is posted on a user's wall
# when they create a new post.
def post_feed_template
one_line_story_template "{*actor*} made a new {*title*} on Blavel."
end
# Defines how a update to a user's My Blavel profile box is published.
def profile_update(user)
send_as :profile
recipients user.facebook_user.facebook_session.user
profile render(:partial => 'facebook_publisher/profile',
:assigns => { :posts => Post.find_all_by_user_id(user.id, :order => 'created_at desc', :limit => 5),
:blavel_user => user,
:facebook_user => user.facebook_user.facebook_session.user })
end
# Defines how an update to a user's wall is published when they create a new
# post.
def post_feed(post)
pictures = Picture.find_all_by_post_id(post.id, :order => 'sequence', :limit => 3)
images = []
pictures.each do |picture|
images.push image(picture.public_filename(:tiny), show_picture_url(:id => picture.id, :host => $DEFAULT_HOST))
end
send_as :user_action
from post.user.facebook_user.facebook_session.user
data :title => post.title.blank? ? link_to('post', verbose_post_path(post, true)) : "post titled '#{link_to(post.title, verbose_post_path(post, true))}'",
:images => images
end
end
| 42.441176 | 158 | 0.704782 |
62d73c3cb31498935c0c91bd3f1d3a42de7025cb | 1,046 | # -*- encoding : utf-8 -*-
module Pacto
class ContractFactory
include Singleton
include Logger
def initialize
@factories = {}
end
def add_factory(format, factory)
@factories[format.to_sym] = factory
end
def remove_factory(format)
@factories.delete format
end
def build(contract_files, host, format = :legacy)
factory = @factories[format.to_sym]
fail "No Contract factory registered for #{format}" if factory.nil?
contract_files.map { |file| factory.build_from_file(file, host) }.flatten
end
def load_contracts(contracts_path, host, format = :legacy)
factory = @factories[format.to_sym]
files = factory.files_for(contracts_path)
contracts = ContractFactory.build(files, host, format)
contracts
end
class << self
extend Forwardable
def_delegators :instance, *ContractFactory.instance_methods(false)
end
end
end
require 'pacto/formats/legacy/contract_factory'
require 'pacto/formats/swagger/contract_factory'
| 24.904762 | 79 | 0.691205 |
5d83561758fc2d07c89e7576ccb5e30cd66867fa | 3,486 | Given(/^I have previously created the "(.*?)" service$/) do |name|
params = { name: name, slug: name.parameterize, csv_path: csv_path_for_data(name) }
@service = create_service(params)
end
Given(/^I have previously created a service with the following attributes:$/) do |table|
params = table.rows_hash.symbolize_keys!
raise ArgumentError, "name cannot be nil" if params[:name].nil?
params = {
slug: params[:name].parameterize,
csv_path: csv_path_for_data(params[:name]),
}.merge(params)
@service = create_service(params)
end
When(/^I go to the new service page$/) do
visit new_admin_service_path
end
When(/^I go to the page for the "(.*?)" service$/) do |name|
visit path_for_service(name)
end
When(/^I visit the details tab$/) do
click_link "Service details"
end
When(/^I visit the history tab$/) do
click_link "Version history"
end
When(/^I fill in the form to create the "(.*?)" service with a bad CSV$/) do |name|
params = {
name: name,
slug: name.parameterize,
csv_path: Rails.root.join("features/support/data/bad.csv"),
}
fill_in_form_with(params)
end
When(/^I fill in the form to create the "(.*?)" service with a PNG claiming to be a CSV$/) do |name|
params = {
name: name,
slug: name.parameterize,
csv_path: Rails.root.join("features/support/data/rails.csv"),
}
fill_in_form_with(params)
end
When(/^I fill in the form to create the "(.*?)" service with a PNG$/) do |name|
params = {
name: name,
slug: name.parameterize,
csv_path: Rails.root.join("features/support/data/rails.png"),
}
fill_in_form_with(params)
end
When(/^I fill out the form with the following attributes to create a service:$/) do |table|
params = table.rows_hash.symbolize_keys!
raise ArgumentError, "name cannot be nil" if params[:name].nil?
params = {
slug: params[:name].parameterize,
csv_path: csv_path_for_data(params[:name]),
}.merge(params)
fill_in_form_with(params)
end
Then(/^I should be on the page for the "(.*?)" service$/) do |name|
current_path = URI.parse(current_url).path
assert_equal path_for_service(name), current_path
end
Then(/^there should not be a "(.*?)" service$/) do |name|
assert_equal 0, Service.where(name: name).count
end
Then(/^I should see that the current service has (\d+) missing SNAC codes$/) do |count|
content = "#{count} places with missing SNAC codes."
assert page.has_content?(content)
end
Then(/^I should not see any text about missing SNAC codes$/) do
assert !page.has_content?("places with missing SNAC codes.")
end
When(/^I activate the most recent data set for the "(.*?)" service$/) do |name|
steps %(
And I go to the page for the "#{name}" service
And I visit the history tab
And I activate the most recent data set
)
end
When(/^I should see (\d+) version panels?$/) do |count|
version_panels = page.all(:css, "div .data-set")
assert_equal version_panels.size, count.to_i
end
Then(/^the first version panel has the title "(.*?)"$/) do |title|
within "div.data-set:nth-child(1)" do
within "h3.panel-title" do
assert page.has_content?(title)
end
end
end
Then(/^the first version panel has the text "(.*?)"$/) do |text|
within "div.data-set:nth-child(1)" do
assert page.has_content?(text)
end
end
Then(/^the first version panel shows a warning about missing SNAC codes$/) do
within "div.data-set:nth-child(1)" do
assert page.has_css?("p.missing-snac-warning")
end
end
| 27.448819 | 100 | 0.687894 |
213c02f8acedcba9cec0d2cbcc074227a26218d1 | 1,958 | require 'test_helper'
class UserTest < ActiveSupport::TestCase
def setup
@user = User.new(name: "Kevin Suh", email: "[email protected]", password: "kevinsuh1", password_confirmation: "kevinsuh1")
end
test "should be valid" do
assert @user.valid?
end
test "name cannot be too long" do
name = 'a' * 51
@user.name = name
assert_not @user.valid?
end
test "email should be present" do
@user.email = " "
assert_not @user.valid?
end
test "email cannot be too long" do
email = 'a' * 256
@user.email = email
assert_not @user.valid?
end
test "email validation should accept valid emails" do
valid_emails = %w[[email protected] [email protected] [email protected] [email protected]]
valid_emails.each do |email|
@user.email = email
assert @user.valid?, "#{email.inspect} should be valid"
end
end
test "email validation should not accept these emails" do
invalid_emails = %w[[email protected] invalidEmail@mail,com invalidEmail_at_test.org email@mail+mail.com [email protected]]
invalid_emails.each do |email|
@user.email = email
assert_not @user.valid?, "#{email} should be marked as invalid, but it's not"
end
end
test "email should be unique" do
duplicate_user = @user.dup
@user.save
assert_not duplicate_user.valid?
# case-sensitivity should not matter in uniqueness
duplicate_user.email = @user.email.upcase
assert_not duplicate_user.valid?
end
test "email should be saved as lowercase" do
mixed_case_email = "[email protected]"
@user.email = mixed_case_email
@user.save
# it should lowercase it via before_save callback
assert_equal mixed_case_email.downcase, @user.email
end
test "password should be valid" do
@user.password = "notvalid"
assert_not @user.valid?
@user.password = @user.password_confirmation = "short" #minimum 6 chars
assert_not @user.valid?
@user.password = @user.password_confirmation = "validpassword1"
assert @user.valid?
end
end
| 24.78481 | 125 | 0.723698 |
62eb7352ba892b7923401484bd849c145196fe44 | 3,533 | # encoding: UTF-8
#
# Copyright (c) 2010-2017 GoodData Corporation. All rights reserved.
# This source code is licensed under the BSD-style license found in the
# LICENSE file in the root directory of this source tree.
require_relative 'base_action'
module GoodData
module LCM2
class CollectSegmentClients < BaseAction
DESCRIPTION = 'Collect Clients'
PARAMS = define_params(self) do
description 'Client Used for Connecting to GD'
param :gdc_gd_client, instance_of(Type::GdClientType), required: true
description 'Organization Name'
param :organization, instance_of(Type::StringType), required: true
description 'ADS Client'
param :ads_client, instance_of(Type::AdsClientType), required: true
description 'Segments to manage'
param :segments, array_of(instance_of(Type::SegmentType)), required: true
description 'Table Name'
param :release_table_name, instance_of(Type::StringType), required: false
end
RESULT_HEADER = [
:from_name,
:from_pid,
:to_name,
:to_pid
]
DEFAULT_TABLE_NAME = 'LCM_RELEASE'
class << self
def call(params)
client = params.gdc_gd_client
domain_name = params.organization || params.domain
domain = client.domain(domain_name) || fail("Invalid domain name specified - #{domain_name}")
domain_segments = domain.segments
segments = params.segments.map do |seg|
domain_segments.find do |s|
s.segment_id == seg.segment_id
end
end
results = []
synchronize_clients = segments.map do |segment|
segment_clients = segment.clients
missing_project_clients = segment_clients.reject(&:project?).map(&:client_id)
raise "Client(s) missing workspace: #{missing_project_clients.join(', ')}. Please make sure all clients have workspace." unless missing_project_clients.empty?
replacements = {
table_name: params.release_table_name || DEFAULT_TABLE_NAME,
segment_id: segment.segment_id
}
path = File.expand_path('../../data/select_from_lcm_release.sql.erb', __FILE__)
query = GoodData::Helpers::ErbHelper.template_file(path, replacements)
res = params.ads_client.execute_select(query)
# TODO: Check res.first.nil? || res.first[:master_project_id].nil?
master = client.projects(res.first[:master_project_id])
master_pid = master.pid
master_name = master.title
sync_info = {
segment_id: segment.segment_id,
from: master_pid,
to: segment_clients.map do |segment_client|
client_project = segment_client.project
to_pid = client_project.pid
results << {
from_name: master_name,
from_pid: master_pid,
to_name: client_project.title,
to_pid: to_pid
}
{
pid: to_pid,
client_id: segment_client.client_id
}
end
}
sync_info
end
results.flatten!
# Return results
{
results: results,
params: {
synchronize: synchronize_clients
}
}
end
end
end
end
end
| 31.265487 | 170 | 0.590716 |
87d277af199035df15a56ec2e92aa24d0e6541fc | 8,498 | =begin
Copyright (c) 2019 Aspose Pty Ltd
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.
=end
require 'date'
module AsposeSlidesCloud
# Represents a series marker
class SeriesMarker
# size
attr_accessor :size
# symbol
attr_accessor :symbol
# Get or sets the fill format.
attr_accessor :fill_format
# Get or sets the effect format.
attr_accessor :effect_format
# Get or sets the line format.
attr_accessor :line_format
class EnumAttributeValidator
attr_reader :datatype
attr_reader :allowable_values
def initialize(datatype, allowable_values)
@allowable_values = allowable_values.map do |value|
case datatype.to_s
when /Integer/i
value.to_i
when /Float/i
value.to_f
else
value
end
end
end
def valid?(value)
!value || allowable_values.any?{ |s| s.casecmp(value) == 0 }
end
end
# Attribute mapping from ruby-style variable name to JSON key.
def self.attribute_map
{
:'size' => :'Size',
:'symbol' => :'Symbol',
:'fill_format' => :'FillFormat',
:'effect_format' => :'EffectFormat',
:'line_format' => :'LineFormat'
}
end
# Attribute type mapping.
def self.swagger_types
{
:'size' => :'Integer',
:'symbol' => :'String',
:'fill_format' => :'FillFormat',
:'effect_format' => :'EffectFormat',
:'line_format' => :'LineFormat'
}
end
# Initializes the object
# @param [Hash] attributes Model attributes in the form of hash
def initialize(attributes = {})
return unless attributes.is_a?(Hash)
# convert string to symbol for hash key
attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
if attributes.has_key?(:'Size')
self.size = attributes[:'Size']
end
if attributes.has_key?(:'Symbol')
self.symbol = attributes[:'Symbol']
end
if attributes.has_key?(:'FillFormat')
self.fill_format = attributes[:'FillFormat']
end
if attributes.has_key?(:'EffectFormat')
self.effect_format = attributes[:'EffectFormat']
end
if attributes.has_key?(:'LineFormat')
self.line_format = attributes[:'LineFormat']
end
end
# Show invalid properties with the reasons. Usually used together with valid?
# @return Array for valid properties with the reasons
def list_invalid_properties
invalid_properties = Array.new
invalid_properties
end
# Check to see if the all the properties in the model are valid
# @return true if the model is valid
def valid?
symbol_validator = EnumAttributeValidator.new('String', ['Circle', 'Dash', 'Diamond', 'Dot', 'None', 'Picture', 'Plus', 'Square', 'Star', 'Triangle', 'X', 'NotDefined'])
return false unless symbol_validator.valid?(@symbol)
true
end
# Custom attribute writer method checking allowed values (enum).
# @param [Object] symbol Object to be assigned
def symbol=(symbol)
validator = EnumAttributeValidator.new('String', ['Circle', 'Dash', 'Diamond', 'Dot', 'None', 'Picture', 'Plus', 'Square', 'Star', 'Triangle', 'X', 'NotDefined'])
unless validator.valid?(symbol)
fail ArgumentError, 'invalid value for "symbol", must be one of #{validator.allowable_values}.'
end
@symbol = symbol
end
# Checks equality by comparing each attribute.
# @param [Object] Object to be compared
def ==(o)
return true if self.equal?(o)
self.class == o.class &&
size == o.size &&
symbol == o.symbol &&
fill_format == o.fill_format &&
effect_format == o.effect_format &&
line_format == o.line_format
end
# @see the `==` method
# @param [Object] Object to be compared
def eql?(o)
self == o
end
# Calculates hash code according to all attributes.
# @return [Fixnum] Hash code
def hash
[size, symbol, fill_format, effect_format, line_format].hash
end
# Builds the object from hash
# @param [Hash] attributes Model attributes in the form of hash
# @return [Object] Returns the model itself
def build_from_hash(attributes)
return nil unless attributes.is_a?(Hash)
self.class.swagger_types.each_pair do |key, type|
if type =~ /\AArray<(.*)>/i
# check to ensure the input is an array given that the the attribute
# is documented as an array but the input is not
if attributes[self.class.attribute_map[key]].is_a?(Array)
self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
end
elsif !attributes[self.class.attribute_map[key]].nil?
self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
end # or else data not found in attributes(hash), not an issue as the data can be optional
end
self
end
# Deserializes the data based on type
# @param string type Data type
# @param string value Value to be deserialized
# @return [Object] Deserialized data
def _deserialize(type, value)
case type.to_sym
when :DateTime
DateTime.parse(value)
when :Date
Date.parse(value)
when :String
value.to_s
when :Integer
value.to_i
when :Float
value.to_f
when :BOOLEAN
if value.to_s =~ /\A(true|t|yes|y|1)\z/i
true
else
false
end
when :Object
# generic object (usually a Hash), return directly
value
when /\AArray<(?<inner_type>.+)>\z/
inner_type = Regexp.last_match[:inner_type]
value.map { |v| _deserialize(inner_type, v) }
when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
k_type = Regexp.last_match[:k_type]
v_type = Regexp.last_match[:v_type]
{}.tap do |hash|
value.each do |k, v|
hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
end
end
else # model
temp_model = AsposeSlidesCloud.const_get(type).new
temp_model.build_from_hash(value)
end
end
# Returns the string representation of the object
# @return [String] String presentation of the object
def to_s
to_hash.to_s
end
# to_body is an alias to to_hash (backward compatibility)
# @return [Hash] Returns the object in the form of hash
def to_body
to_hash
end
# Returns the object in the form of hash
# @return [Hash] Returns the object in the form of hash
def to_hash
hash = {}
self.class.attribute_map.each_pair do |attr, param|
value = self.send(attr)
next if value.nil?
hash[param] = _to_hash(value)
end
hash
end
# Outputs non-array value in the form of hash
# For object, use to_hash. Otherwise, just return the value
# @param [Object] value Any valid value
# @return [Hash] Returns the value in the form of hash
def _to_hash(value)
if value.is_a?(Array)
value.compact.map { |v| _to_hash(v) }
elsif value.is_a?(Hash)
{}.tap do |hash|
value.each { |k, v| hash[k] = _to_hash(v) }
end
elsif value.respond_to? :to_hash
value.to_hash
else
value
end
end
end
end
| 31.474074 | 175 | 0.631796 |
bb1f100adc03dabf3d0cf34621a59b0a06136a9e | 297 | #--
#
#
#
# Copyright (c) 1999-2006 Minero Aoki
#
# This program is free software.
# You can distribute/modify this program under the same terms of ruby.
# see the file "COPYING".
#
#++
module Racc
VERSION = '1.6.0'
Version = VERSION
Copyright = 'Copyright (c) 1999-2006 Minero Aoki'
end
| 16.5 | 70 | 0.673401 |
f8875de0a2a9f016ac4297855ff38a1ed4c70db3 | 288 | $LOAD_PATH.unshift File.expand_path("../lib", __dir__)
require 'simplecov'
require 'oneshot_coverage/simplecov_reporter'
OneshotCoverage::SimplecovReporter.new(
project_path: Dir.pwd,
log_path: 'coverage.json',
file_filter: OneshotCoverage::SimplecovReporter::DefaultFilter
).run
| 26.181818 | 64 | 0.798611 |
268a08bff1471c5ec932eb4037fa2cd51e06404c | 5,335 | require "active_support/core_ext/integer/time"
Rails.application.configure do
# Settings specified here will take precedence over those in config/application.rb.
# Code is not reloaded between requests.
config.cache_classes = true
# Eager load code on boot. This eager loads most of Rails and
# your application in memory, allowing both threaded web servers
# and those relying on copy on write to perform better.
# Rake tasks automatically ignore this option for performance.
config.eager_load = true
# Full error reports are disabled and caching is turned on.
config.consider_all_requests_local = false
config.action_controller.perform_caching = true
# Ensures that a master key has been made available in either ENV["RAILS_MASTER_KEY"]
# or in config/master.key. This key is used to decrypt credentials (and other encrypted files).
# config.require_master_key = true
# Disable serving static files from the `/public` folder by default since
# Apache or NGINX already handles this.
config.public_file_server.enabled = ENV['RAILS_SERVE_STATIC_FILES'].present?
# Compress CSS using a preprocessor.
# config.assets.css_compressor = :sass
# Do not fallback to assets pipeline if a precompiled asset is missed.
config.assets.compile = false
# Enable serving of images, stylesheets, and JavaScripts from an asset server.
# config.asset_host = 'http://assets.example.com'
# Specifies the header that your server uses for sending files.
# config.action_dispatch.x_sendfile_header = 'X-Sendfile' # for Apache
# config.action_dispatch.x_sendfile_header = 'X-Accel-Redirect' # for NGINX
# Store uploaded files on the local file system (see config/storage.yml for options).
config.active_storage.service = :local
# Mount Action Cable outside main process or domain.
# config.action_cable.mount_path = nil
# config.action_cable.url = 'wss://example.com/cable'
# config.action_cable.allowed_request_origins = [ 'http://example.com', /http:\/\/example.*/ ]
# Force all access to the app over SSL, use Strict-Transport-Security, and use secure cookies.
# config.force_ssl = true
# Include generic and useful information about system operation, but avoid logging too much
# information to avoid inadvertent exposure of personally identifiable information (PII).
config.log_level = :info
# Prepend all log lines with the following tags.
config.log_tags = [ :request_id ]
# Use a different cache store in production.
# config.cache_store = :mem_cache_store
# Use a real queuing backend for Active Job (and separate queues per environment).
# config.active_job.queue_adapter = :resque
# config.active_job.queue_name_prefix = "demo_app_production"
config.action_mailer.perform_caching = false
# Ignore bad email addresses and do not raise email delivery errors.
# Set this to true and configure the email server for immediate delivery to raise delivery errors.
# config.action_mailer.raise_delivery_errors = false
# Enable locale fallbacks for I18n (makes lookups for any locale fall back to
# the I18n.default_locale when a translation cannot be found).
config.i18n.fallbacks = true
# Send deprecation notices to registered listeners.
config.active_support.deprecation = :notify
# Log disallowed deprecations.
config.active_support.disallowed_deprecation = :log
# Tell Active Support which deprecation messages to disallow.
config.active_support.disallowed_deprecation_warnings = []
# Use default logging formatter so that PID and timestamp are not suppressed.
config.log_formatter = ::Logger::Formatter.new
# Use a different logger for distributed setups.
# require "syslog/logger"
# config.logger = ActiveSupport::TaggedLogging.new(Syslog::Logger.new 'app-name')
if ENV["RAILS_LOG_TO_STDOUT"].present?
logger = ActiveSupport::Logger.new(STDOUT)
logger.formatter = config.log_formatter
config.logger = ActiveSupport::TaggedLogging.new(logger)
end
# Do not dump schema after migrations.
config.active_record.dump_schema_after_migration = false
# Inserts middleware to perform automatic connection switching.
# The `database_selector` hash is used to pass options to the DatabaseSelector
# middleware. The `delay` is used to determine how long to wait after a write
# to send a subsequent read to the primary.
#
# The `database_resolver` class is used by the middleware to determine which
# database is appropriate to use based on the time delay.
#
# The `database_resolver_context` class is used by the middleware to set
# timestamps for the last write to the primary. The resolver uses the context
# class timestamps to determine how long to wait before reading from the
# replica.
#
# By default Rails will store a last write timestamp in the session. The
# DatabaseSelector middleware is designed as such you can define your own
# strategy for connection switching and pass that into the middleware through
# these configuration options.
# config.active_record.database_selector = { delay: 2.seconds }
# config.active_record.database_resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver
# config.active_record.database_resolver_context = ActiveRecord::Middleware::DatabaseSelector::Resolver::Session
end
| 44.090909 | 114 | 0.765323 |
21178e24999dca9045e32181f0065ceee7e1649b | 231 | module MiqAeMethodService
class MiqAeServiceSwitch < MiqAeServiceModelBase
expose :hosts, :association => true
expose :guest_devices, :association => true
expose :lans, :association => true
end
end
| 28.875 | 50 | 0.688312 |
e91ac11d9d7260f38822128e992941057ddf4141 | 1,279 | # frozen_string_literal: true
Rails.application.configure do
# Settings specified here will take precedence over those in config/application.rb
# In the development environment your application's code is reloaded on
# every request. This slows down response time but is perfect for development
# since you don't have to restart the web server when you make code changes.
config.cache_classes = false
config.eager_load = false
# Log error messages when you accidentally call methods on nil.
config.whiny_nils = true
# Show full error reports and disable caching
config.consider_all_requests_local = true
config.action_controller.perform_caching = false
# Don't care if the mailer can't send
config.action_mailer.raise_delivery_errors = true
config.action_mailer.perform_deliveries = true
# Print deprecation notices to the Rails logger
config.active_support.deprecation = :log
# Only use best-standards-support built into browsers
config.action_dispatch.best_standards_support = :builtin
# Expands the lines which load the assets
config.assets.debug = true
config.action_mailer.default_url_options = { host: 'localhost:3000' }
# Bullet gem
Bullet.enable = true
Bullet.bullet_logger = true
Bullet.rails_logger = true
end
| 32.794872 | 84 | 0.778733 |
03130cc3b745dff964776b005cc362fff875964f | 1,682 | require File.expand_path('../../spec_helper', __FILE__)
describe JobQueue do
before do
@q = JobQueue.new 2
$job_queue_results = Set.new
$job_queue_runs = 0
$job_queue_data_mutex = Mutex.new
end
class TestWorker
def perform(item, delay)
sleep delay
$job_queue_data_mutex.synchronize do
$job_queue_results.add item
$job_queue_runs += 1
end
end
end
it 'should queue and run a job' do
expect($job_queue_results.member? 'a').to be_falsey
@q.enqueue(TestWorker, 'a', 0.1)
expect($job_queue_results.member? 'a').to be_falsey
@q.wait_for_all_jobs
expect($job_queue_results.member? 'a').to be_truthy
end
it 'should run multiple jobs in background' do
expect($job_queue_results.member? 'a').to be_falsey
expect($job_queue_results.member? 'b').to be_falsey
@q.enqueue(TestWorker, 'a', 0.05)
@q.enqueue(TestWorker, 'b', 0.05)
expect($job_queue_results.member? 'a').to be_falsey
expect($job_queue_results.member? 'b').to be_falsey
sleep 0.1
expect($job_queue_results.member? 'a').to be_truthy
expect($job_queue_results.member? 'b').to be_truthy
end
it 'should run concurrent non-unique jobs' do
@q.enqueue(TestWorker, 'a', 0.05)
@q.enqueue(TestWorker, 'a', 0.05)
sleep 0.1
expect($job_queue_runs).to eq(2)
end
it 'should not start currently running unique jobs' do
@q.make_job_unique(TestWorker, 'a', 0.05)
@q.enqueue(TestWorker, 'a', 0.05)
@q.enqueue(TestWorker, 'a', 0.05)
sleep 0.1
expect($job_queue_runs).to eq(1)
@q.enqueue(TestWorker, 'a', 0.05)
sleep 0.1
expect($job_queue_runs).to eq(2)
end
end | 28.508475 | 56 | 0.669441 |
331145218374d37d24b560c6c4bf4eb80b347b1f | 16,010 | ##
# This code was generated by
# \ / _ _ _| _ _
# | (_)\/(_)(_|\/| |(/_ v1.0.0
# / /
module Twilio
module REST
class Api < Domain
class V2010 < Version
class AccountContext < InstanceContext
class SipList < ListResource
class IpAccessControlListList < ListResource
##
# Initialize the IpAccessControlListList
# @param [Version] version Version that contains the resource
# @param [String] account_sid A 34 character string that uniquely identifies this
# resource.
# @return [IpAccessControlListList] IpAccessControlListList
def initialize(version, account_sid: nil)
super(version)
# Path Solution
@solution = {account_sid: account_sid}
@uri = "/Accounts/#{@solution[:account_sid]}/SIP/IpAccessControlLists.json"
end
##
# Lists IpAccessControlListInstance records from the API as a list.
# Unlike stream(), this operation is eager and will load `limit` records into
# memory before returning.
# @param [Integer] limit Upper limit for the number of records to return. stream()
# guarantees to never return more than limit. Default is no limit
# @param [Integer] page_size Number of records to fetch per request, when
# not set will use the default value of 50 records. If no page_size is defined
# but a limit is defined, stream() will attempt to read the limit with the most
# efficient page size, i.e. min(limit, 1000)
# @return [Array] Array of up to limit results
def list(limit: nil, page_size: nil)
self.stream(limit: limit, page_size: page_size).entries
end
##
# Streams IpAccessControlListInstance records from the API as an Enumerable.
# This operation lazily loads records as efficiently as possible until the limit
# is reached.
# @param [Integer] limit Upper limit for the number of records to return. stream()
# guarantees to never return more than limit. Default is no limit.
# @param [Integer] page_size Number of records to fetch per request, when
# not set will use the default value of 50 records. If no page_size is defined
# but a limit is defined, stream() will attempt to read the limit with the most
# efficient page size, i.e. min(limit, 1000)
# @return [Enumerable] Enumerable that will yield up to limit results
def stream(limit: nil, page_size: nil)
limits = @version.read_limits(limit, page_size)
page = self.page(page_size: limits[:page_size], )
@version.stream(page, limit: limits[:limit], page_limit: limits[:page_limit])
end
##
# When passed a block, yields IpAccessControlListInstance records from the API.
# This operation lazily loads records as efficiently as possible until the limit
# is reached.
def each
limits = @version.read_limits
page = self.page(page_size: limits[:page_size], )
@version.stream(page,
limit: limits[:limit],
page_limit: limits[:page_limit]).each {|x| yield x}
end
##
# Retrieve a single page of IpAccessControlListInstance records from the API.
# Request is executed immediately.
# @param [String] page_token PageToken provided by the API
# @param [Integer] page_number Page Number, this value is simply for client state
# @param [Integer] page_size Number of records to return, defaults to 50
# @return [Page] Page of IpAccessControlListInstance
def page(page_token: :unset, page_number: :unset, page_size: :unset)
params = Twilio::Values.of({
'PageToken' => page_token,
'Page' => page_number,
'PageSize' => page_size,
})
response = @version.page(
'GET',
@uri,
params
)
IpAccessControlListPage.new(@version, response, @solution)
end
##
# Retrieve a single page of IpAccessControlListInstance records from the API.
# Request is executed immediately.
# @param [String] target_url API-generated URL for the requested results page
# @return [Page] Page of IpAccessControlListInstance
def get_page(target_url)
response = @version.domain.request(
'GET',
target_url
)
IpAccessControlListPage.new(@version, response, @solution)
end
##
# Retrieve a single page of IpAccessControlListInstance records from the API.
# Request is executed immediately.
# @param [String] friendly_name A human readable descriptive text that describes
# the IpAccessControlList, up to 64 characters long.
# https://www.twilio.com/docs/admin/pages/add/api_reference/apireferencepage/175/#
# @return [IpAccessControlListInstance] Newly created IpAccessControlListInstance
def create(friendly_name: nil)
data = Twilio::Values.of({'FriendlyName' => friendly_name, })
payload = @version.create(
'POST',
@uri,
data: data
)
IpAccessControlListInstance.new(@version, payload, account_sid: @solution[:account_sid], )
end
##
# Provide a user friendly representation
def to_s
'#<Twilio.Api.V2010.IpAccessControlListList>'
end
end
class IpAccessControlListPage < Page
##
# Initialize the IpAccessControlListPage
# @param [Version] version Version that contains the resource
# @param [Response] response Response from the API
# @param [Hash] solution Path solution for the resource
# @return [IpAccessControlListPage] IpAccessControlListPage
def initialize(version, response, solution)
super(version, response)
# Path Solution
@solution = solution
end
##
# Build an instance of IpAccessControlListInstance
# @param [Hash] payload Payload response from the API
# @return [IpAccessControlListInstance] IpAccessControlListInstance
def get_instance(payload)
IpAccessControlListInstance.new(@version, payload, account_sid: @solution[:account_sid], )
end
##
# Provide a user friendly representation
def to_s
'<Twilio.Api.V2010.IpAccessControlListPage>'
end
end
class IpAccessControlListContext < InstanceContext
##
# Initialize the IpAccessControlListContext
# @param [Version] version Version that contains the resource
# @param [String] account_sid The account_sid
# @param [String] sid The ip-access-control-list Sid that uniquely identifies this
# resource
# @return [IpAccessControlListContext] IpAccessControlListContext
def initialize(version, account_sid, sid)
super(version)
# Path Solution
@solution = {account_sid: account_sid, sid: sid, }
@uri = "/Accounts/#{@solution[:account_sid]}/SIP/IpAccessControlLists/#{@solution[:sid]}.json"
# Dependents
@ip_addresses = nil
end
##
# Fetch a IpAccessControlListInstance
# @return [IpAccessControlListInstance] Fetched IpAccessControlListInstance
def fetch
params = Twilio::Values.of({})
payload = @version.fetch(
'GET',
@uri,
params,
)
IpAccessControlListInstance.new(
@version,
payload,
account_sid: @solution[:account_sid],
sid: @solution[:sid],
)
end
##
# Update the IpAccessControlListInstance
# @param [String] friendly_name A human readable descriptive text, up to 64
# characters long.
# @return [IpAccessControlListInstance] Updated IpAccessControlListInstance
def update(friendly_name: nil)
data = Twilio::Values.of({'FriendlyName' => friendly_name, })
payload = @version.update(
'POST',
@uri,
data: data,
)
IpAccessControlListInstance.new(
@version,
payload,
account_sid: @solution[:account_sid],
sid: @solution[:sid],
)
end
##
# Deletes the IpAccessControlListInstance
# @return [Boolean] true if delete succeeds, true otherwise
def delete
@version.delete('delete', @uri)
end
##
# Access the ip_addresses
# @return [IpAddressList]
# @return [IpAddressContext] if sid was passed.
def ip_addresses(sid=:unset)
raise ArgumentError, 'sid cannot be nil' if sid.nil?
if sid != :unset
return IpAddressContext.new(@version, @solution[:account_sid], @solution[:sid], sid, )
end
unless @ip_addresses
@ip_addresses = IpAddressList.new(
@version,
account_sid: @solution[:account_sid],
ip_access_control_list_sid: @solution[:sid],
)
end
@ip_addresses
end
##
# Provide a user friendly representation
def to_s
context = @solution.map {|k, v| "#{k}: #{v}"}.join(',')
"#<Twilio.Api.V2010.IpAccessControlListContext #{context}>"
end
end
class IpAccessControlListInstance < InstanceResource
##
# Initialize the IpAccessControlListInstance
# @param [Version] version Version that contains the resource
# @param [Hash] payload payload that contains response from Twilio
# @param [String] account_sid A 34 character string that uniquely identifies this
# resource.
# @param [String] sid The ip-access-control-list Sid that uniquely identifies this
# resource
# @return [IpAccessControlListInstance] IpAccessControlListInstance
def initialize(version, payload, account_sid: nil, sid: nil)
super(version)
# Marshaled Properties
@properties = {
'sid' => payload['sid'],
'account_sid' => payload['account_sid'],
'friendly_name' => payload['friendly_name'],
'date_created' => Twilio.deserialize_rfc2822(payload['date_created']),
'date_updated' => Twilio.deserialize_rfc2822(payload['date_updated']),
'subresource_uris' => payload['subresource_uris'],
'uri' => payload['uri'],
}
# Context
@instance_context = nil
@params = {'account_sid' => account_sid, 'sid' => sid || @properties['sid'], }
end
##
# Generate an instance context for the instance, the context is capable of
# performing various actions. All instance actions are proxied to the context
# @return [IpAccessControlListContext] IpAccessControlListContext for this IpAccessControlListInstance
def context
unless @instance_context
@instance_context = IpAccessControlListContext.new(@version, @params['account_sid'], @params['sid'], )
end
@instance_context
end
##
# @return [String] A string that uniquely identifies this resource
def sid
@properties['sid']
end
##
# @return [String] The unique sid that identifies this account
def account_sid
@properties['account_sid']
end
##
# @return [String] A human readable description of this resource
def friendly_name
@properties['friendly_name']
end
##
# @return [Time] The date this resource was created
def date_created
@properties['date_created']
end
##
# @return [Time] The date this resource was last updated
def date_updated
@properties['date_updated']
end
##
# @return [String] The subresource_uris
def subresource_uris
@properties['subresource_uris']
end
##
# @return [String] The URI for this resource
def uri
@properties['uri']
end
##
# Fetch a IpAccessControlListInstance
# @return [IpAccessControlListInstance] Fetched IpAccessControlListInstance
def fetch
context.fetch
end
##
# Update the IpAccessControlListInstance
# @param [String] friendly_name A human readable descriptive text, up to 64
# characters long.
# @return [IpAccessControlListInstance] Updated IpAccessControlListInstance
def update(friendly_name: nil)
context.update(friendly_name: friendly_name, )
end
##
# Deletes the IpAccessControlListInstance
# @return [Boolean] true if delete succeeds, true otherwise
def delete
context.delete
end
##
# Access the ip_addresses
# @return [ip_addresses] ip_addresses
def ip_addresses
context.ip_addresses
end
##
# Provide a user friendly representation
def to_s
values = @params.map{|k, v| "#{k}: #{v}"}.join(" ")
"<Twilio.Api.V2010.IpAccessControlListInstance #{values}>"
end
##
# Provide a detailed, user friendly representation
def inspect
values = @properties.map{|k, v| "#{k}: #{v}"}.join(" ")
"<Twilio.Api.V2010.IpAccessControlListInstance #{values}>"
end
end
end
end
end
end
end
end | 40.634518 | 120 | 0.524422 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.