204 lines
7 KiB
Ruby
204 lines
7 KiB
Ruby
require 'spec_helper'
|
|
|
|
describe Gitlab::UsageData do
|
|
let(:projects) { create_list(:project, 3) }
|
|
let!(:board) { create(:board, project: projects[0]) }
|
|
|
|
describe '#data' do
|
|
before do
|
|
create(:jira_service, project: projects[0])
|
|
create(:jira_service, project: projects[1])
|
|
create(:jira_cloud_service, project: projects[2])
|
|
create(:prometheus_service, project: projects[1])
|
|
create(:service, project: projects[0], type: 'SlackSlashCommandsService', active: true)
|
|
create(:service, project: projects[1], type: 'SlackService', active: true)
|
|
create(:service, project: projects[2], type: 'SlackService', active: true)
|
|
|
|
gcp_cluster = create(:cluster, :provided_by_gcp)
|
|
create(:cluster, :provided_by_user)
|
|
create(:cluster, :provided_by_user, :disabled)
|
|
create(:clusters_applications_helm, :installed, cluster: gcp_cluster)
|
|
create(:clusters_applications_ingress, :installed, cluster: gcp_cluster)
|
|
create(:clusters_applications_cert_managers, :installed, cluster: gcp_cluster)
|
|
create(:clusters_applications_prometheus, :installed, cluster: gcp_cluster)
|
|
create(:clusters_applications_runner, :installed, cluster: gcp_cluster)
|
|
create(:clusters_applications_knative, :installed, cluster: gcp_cluster)
|
|
end
|
|
|
|
subject { described_class.data }
|
|
|
|
it "gathers usage data" do
|
|
expect(subject.keys).to match_array(%i(
|
|
active_user_count
|
|
counts
|
|
recorded_at
|
|
edition
|
|
version
|
|
installation_type
|
|
uuid
|
|
hostname
|
|
mattermost_enabled
|
|
signup_enabled
|
|
ldap_enabled
|
|
gravatar_enabled
|
|
omniauth_enabled
|
|
reply_by_email_enabled
|
|
container_registry_enabled
|
|
gitlab_shared_runners_enabled
|
|
gitlab_pages
|
|
git
|
|
database
|
|
avg_cycle_analytics
|
|
web_ide_commits
|
|
))
|
|
end
|
|
|
|
it "gathers usage counts" do
|
|
count_data = subject[:counts]
|
|
|
|
expect(count_data[:boards]).to eq(1)
|
|
expect(count_data[:projects]).to eq(3)
|
|
|
|
expect(count_data.keys).to match_array(%i(
|
|
assignee_lists
|
|
boards
|
|
ci_builds
|
|
ci_internal_pipelines
|
|
ci_external_pipelines
|
|
ci_pipeline_config_auto_devops
|
|
ci_pipeline_config_repository
|
|
ci_runners
|
|
ci_triggers
|
|
ci_pipeline_schedules
|
|
auto_devops_enabled
|
|
auto_devops_disabled
|
|
deploy_keys
|
|
deployments
|
|
environments
|
|
clusters
|
|
clusters_enabled
|
|
clusters_disabled
|
|
clusters_platforms_gke
|
|
clusters_platforms_user
|
|
clusters_applications_helm
|
|
clusters_applications_ingress
|
|
clusters_applications_cert_managers
|
|
clusters_applications_prometheus
|
|
clusters_applications_runner
|
|
clusters_applications_knative
|
|
in_review_folder
|
|
groups
|
|
issues
|
|
keys
|
|
label_lists
|
|
labels
|
|
lfs_objects
|
|
merge_requests
|
|
milestone_lists
|
|
milestones
|
|
notes
|
|
projects
|
|
projects_imported_from_github
|
|
projects_jira_active
|
|
projects_jira_server_active
|
|
projects_jira_cloud_active
|
|
projects_slack_notifications_active
|
|
projects_slack_slash_active
|
|
projects_prometheus_active
|
|
pages_domains
|
|
protected_branches
|
|
releases
|
|
remote_mirrors
|
|
snippets
|
|
todos
|
|
uploads
|
|
web_hooks
|
|
))
|
|
end
|
|
|
|
it 'gathers projects data correctly' do
|
|
count_data = subject[:counts]
|
|
|
|
expect(count_data[:projects]).to eq(3)
|
|
expect(count_data[:projects_prometheus_active]).to eq(1)
|
|
expect(count_data[:projects_jira_active]).to eq(3)
|
|
expect(count_data[:projects_jira_server_active]).to eq(2)
|
|
expect(count_data[:projects_jira_cloud_active]).to eq(1)
|
|
expect(count_data[:projects_slack_notifications_active]).to eq(2)
|
|
expect(count_data[:projects_slack_slash_active]).to eq(1)
|
|
|
|
expect(count_data[:clusters_enabled]).to eq(6)
|
|
expect(count_data[:clusters_disabled]).to eq(1)
|
|
expect(count_data[:clusters_platforms_gke]).to eq(1)
|
|
expect(count_data[:clusters_platforms_user]).to eq(1)
|
|
expect(count_data[:clusters_applications_helm]).to eq(1)
|
|
expect(count_data[:clusters_applications_ingress]).to eq(1)
|
|
expect(count_data[:clusters_applications_cert_managers]).to eq(1)
|
|
expect(count_data[:clusters_applications_prometheus]).to eq(1)
|
|
expect(count_data[:clusters_applications_runner]).to eq(1)
|
|
expect(count_data[:clusters_applications_knative]).to eq(1)
|
|
end
|
|
|
|
it 'works when queries time out' do
|
|
allow_any_instance_of(ActiveRecord::Relation)
|
|
.to receive(:count).and_raise(ActiveRecord::StatementInvalid.new(''))
|
|
|
|
expect { subject }.not_to raise_error
|
|
end
|
|
end
|
|
|
|
describe '#features_usage_data_ce' do
|
|
subject { described_class.features_usage_data_ce }
|
|
|
|
it 'gathers feature usage data' do
|
|
expect(subject[:mattermost_enabled]).to eq(Gitlab.config.mattermost.enabled)
|
|
expect(subject[:signup_enabled]).to eq(Gitlab::CurrentSettings.allow_signup?)
|
|
expect(subject[:ldap_enabled]).to eq(Gitlab.config.ldap.enabled)
|
|
expect(subject[:gravatar_enabled]).to eq(Gitlab::CurrentSettings.gravatar_enabled?)
|
|
expect(subject[:omniauth_enabled]).to eq(Gitlab::Auth.omniauth_enabled?)
|
|
expect(subject[:reply_by_email_enabled]).to eq(Gitlab::IncomingEmail.enabled?)
|
|
expect(subject[:container_registry_enabled]).to eq(Gitlab.config.registry.enabled)
|
|
expect(subject[:gitlab_shared_runners_enabled]).to eq(Gitlab.config.gitlab_ci.shared_runners_enabled)
|
|
end
|
|
end
|
|
|
|
describe '#components_usage_data' do
|
|
subject { described_class.components_usage_data }
|
|
|
|
it 'gathers components usage data' do
|
|
expect(subject[:gitlab_pages][:enabled]).to eq(Gitlab.config.pages.enabled)
|
|
expect(subject[:gitlab_pages][:version]).to eq(Gitlab::Pages::VERSION)
|
|
expect(subject[:git][:version]).to eq(Gitlab::Git.version)
|
|
expect(subject[:database][:adapter]).to eq(Gitlab::Database.adapter_name)
|
|
expect(subject[:database][:version]).to eq(Gitlab::Database.version)
|
|
end
|
|
end
|
|
|
|
describe '#license_usage_data' do
|
|
subject { described_class.license_usage_data }
|
|
|
|
it "gathers license data" do
|
|
expect(subject[:uuid]).to eq(Gitlab::CurrentSettings.uuid)
|
|
expect(subject[:version]).to eq(Gitlab::VERSION)
|
|
expect(subject[:installation_type]).to eq(Gitlab::INSTALLATION_TYPE)
|
|
expect(subject[:active_user_count]).to eq(User.active.count)
|
|
expect(subject[:recorded_at]).to be_a(Time)
|
|
end
|
|
end
|
|
|
|
describe '#count' do
|
|
let(:relation) { double(:relation) }
|
|
|
|
it 'returns the count when counting succeeds' do
|
|
allow(relation).to receive(:count).and_return(1)
|
|
|
|
expect(described_class.count(relation)).to eq(1)
|
|
end
|
|
|
|
it 'returns the fallback value when counting fails' do
|
|
allow(relation).to receive(:count).and_raise(ActiveRecord::StatementInvalid.new(''))
|
|
|
|
expect(described_class.count(relation, fallback: 15)).to eq(15)
|
|
end
|
|
end
|
|
end
|