cartodb-4.42/spec/lib/initializers/carto_db_spec.rb

215 lines
8.7 KiB
Ruby
Raw Normal View History

2024-04-06 13:25:13 +08:00
require_relative '../../spec_helper'
require_relative '../../../spec/doubles/request'
module CartoDB
def self.clear_internal_cache
remove_class_variable(:@@request_host) if defined?(@@request_host)
remove_class_variable(:@@hostname) if defined?(@@hostname)
remove_class_variable(:@@http_port) if defined?(@@http_port)
remove_class_variable(:@@https_port) if defined?(@@http_ports)
remove_class_variable(:@@session_domain) if defined?(@@session_domain)
remove_class_variable(:@@domain) if defined?(@@domain)
remove_class_variable(:@@subdomainless_urls) if defined?(@@subdomainless_urls)
remove_class_variable(:@@account_host) if defined?(@@account_host)
remove_class_variable(:@@account_path) if defined?(@@account_path)
remove_class_variable(:@@data_library_path) if defined?(@@data_library_path)
end
end
describe CartoDB do
after(:each) do
CartoDB.clear_internal_cache
end
describe '#url_methods' do
it 'Tests extract_real_subdomain()' do
username = 'test'
expected_session_domain = '.carto.com'
CartoDB.clear_internal_cache
CartoDB.expects(:get_session_domain).returns(expected_session_domain)
request = Doubles::Request.new({
host: "#{username}#{expected_session_domain}"
})
CartoDB.subdomain_from_request(request).should eq username
end
it 'Tests extract_host_subdomain()' do
username = 'test'
expected_session_domain = '.carto.com'
CartoDB.expects(:get_session_domain).returns(expected_session_domain)
# test.carto.com
request = Doubles::Request.new({
host: "#{username}#{expected_session_domain}"
})
CartoDB.extract_host_subdomain(request).should eq nil
# test.carto.com/u/whatever
request = Doubles::Request.new({
host: "#{username}#{expected_session_domain}",
params: {
user_domain: 'whatever'
}
})
CartoDB.extract_host_subdomain(request).should eq username
end
it 'Tests extract_subdomain() and username_from_request()' do
username = 'test'
orgname = 'testorg'
user_domain = 'whatever'
expected_session_domain = '.carto.com'
CartoDB.expects(:get_session_domain).at_least(0).returns(expected_session_domain)
# testorg.carto.com/u/whatever
request = Doubles::Request.new({
host: "#{orgname}#{expected_session_domain}",
params: {
user_domain: user_domain
}
})
CartoDB.username_from_request(request).should eq user_domain
# test.carto.com
request = Doubles::Request.new({
host: "#{username}#{expected_session_domain}"
})
CartoDB.username_from_request(request).should eq nil
# For extract_subdomain() no need to call again real methods
user_domain_param = "test_user"
host_username = "another_user"
host = "#{host_username}#{expected_session_domain}"
CartoDB.extract_subdomain(Doubles::Request.new({
params: { user_domain: user_domain_param}
}))
.should eq user_domain_param
CartoDB.extract_subdomain(Doubles::Request.new({
host: host
}))
.should eq host_username
end
it 'Tests base_url()' do
expected_session_domain = '.carto.com'
expected_http_port = ':12345'
expected_https_port = ':67890'
username = 'test'
orgname = 'testorg'
protocol_override_https = 'https'
protocol_override_http = 'http'
CartoDB.expects(:get_subdomainless_urls).returns(false)
CartoDB.expects(:use_https?).at_least(0).returns(false)
CartoDB.expects(:get_session_domain).returns(expected_session_domain)
CartoDB.expects(:get_http_port).at_least(1).returns(expected_http_port)
CartoDB.expects(:get_https_port).at_least(1).returns(expected_https_port)
CartoDB.base_url(username, nil, nil).should eq "http://#{username}#{expected_session_domain}#{expected_http_port}"
CartoDB.base_url(username, nil, protocol_override_https)
.should eq "#{protocol_override_https}://#{username}#{expected_session_domain}#{expected_https_port}"
CartoDB.base_url(orgname, username, nil)
.should eq "http://#{orgname}#{expected_session_domain}#{expected_http_port}/u/#{username}"
CartoDB.base_url(orgname, username, protocol_override_https)
.should eq "#{protocol_override_https}://#{orgname}#{expected_session_domain}#{expected_https_port}/u/#{username}"
CartoDB.unstub(:use_https?)
CartoDB.expects(:use_https?).at_least(0).returns(true)
CartoDB.base_url(username, nil, nil)
.should eq "https://#{username}#{expected_session_domain}#{expected_https_port}"
CartoDB.base_url(username, nil, protocol_override_http)
.should eq "#{protocol_override_http}://#{username}#{expected_session_domain}#{expected_http_port}"
# Reset and check without subdomains
CartoDB.clear_internal_cache
expected_session_domain = 'carto.com'
CartoDB.unstub(:get_subdomainless_urls)
CartoDB.expects(:get_subdomainless_urls).returns(true)
CartoDB.unstub(:get_session_domain)
CartoDB.expects(:get_session_domain).returns(expected_session_domain)
CartoDB.expects(:use_https?).at_least(0).returns(false)
CartoDB.base_url(username, nil, nil)
.should eq "http://#{expected_session_domain}#{expected_http_port}/user/#{username}"
CartoDB.base_url(username, nil, protocol_override_https)
.should eq "#{protocol_override_https}://#{expected_session_domain}#{expected_https_port}/user/#{username}"
# Because without subdomains organizations are ignored, acts as previous scenario
CartoDB.base_url(orgname, username, nil)
.should eq "http://#{expected_session_domain}#{expected_http_port}/user/#{orgname}"
CartoDB.base_url(orgname, username, protocol_override_https)
.should eq "#{protocol_override_https}://#{expected_session_domain}#{expected_https_port}/user/#{orgname}"
CartoDB.unstub(:use_https?)
CartoDB.expects(:use_https?).at_least(0).returns(true)
CartoDB.base_url(username, nil, nil)
.should eq "https://#{expected_session_domain}#{expected_https_port}/user/#{username}"
CartoDB.base_url(username, nil, protocol_override_http)
.should eq "#{protocol_override_http}://#{expected_session_domain}#{expected_http_port}/user/#{username}"
end
it 'tests base_url() without logged user' do
expected_session_domain = 'carto.com'
expected_ip = '127.0.0.1'
expected_https_port = ':67890'
CartoDB.clear_internal_cache
CartoDB.stubs(:use_https?).returns(true)
CartoDB.stubs(:get_https_port).returns(expected_https_port)
CartoDB.stubs(:get_subdomainless_urls).returns(true)
CartoDB.stubs(:get_session_domain).returns(expected_session_domain)
CartoDB.base_url(nil, nil, nil).should eq "https://#{expected_session_domain}#{expected_https_port}"
CartoDB.stubs(:request_host).returns(expected_ip)
CartoDB.base_url(nil, nil, nil).should eq "https://#{expected_ip}#{expected_https_port}"
end
end
describe '#base_domain_from_request' do
it 'extracts subdomain without domain based urls' do
CartoDB.stubs(:subdomainless_urls?).returns(false)
CartoDB.stubs(:session_domain).returns('.localhost.lan')
CartoDB.stubs(:protocol).returns('http')
CartoDB.base_domain_from_request(
OpenStruct.new(host: 'auser.localhost.lan', params: { user_domain: 'buser' })
).should == "http://auser.localhost.lan#{CartoDB.http_port}"
CartoDB.base_domain_from_request(
OpenStruct.new(host: 'org.localhost.lan', params: { user_domain: 'auser' })
).should == "http://org.localhost.lan#{CartoDB.http_port}"
end
it 'extracts subdomain with subdomainless urls' do
CartoDB.stubs(:subdomainless_urls?).returns(true)
CartoDB.stubs(:session_domain).returns('localhost.lan')
CartoDB.stubs(:protocol).returns('http')
CartoDB.base_domain_from_request(
OpenStruct.new(host: 'localhost.lan', params: { user_domain: 'auser' })
).should == "http://localhost.lan#{CartoDB.http_port}"
end
end
end