Add latest changes from gitlab-org/gitlab@master

spec/frontend/error_tracking/components/error_tracking_list_spec.js

@@ -239,7 +239,7 @@ describe('ErrorTrackingList', () => {
       expect(actions.updateStatus).toHaveBeenCalledWith(
         expect.anything(),
         {
-          endpoint: '/project/test/-/error_tracking/3.json',
+          endpoint: `/project/test/-/error_tracking/${errorsList[0].id}.json`,
           redirectUrl: '/error_tracking',
           status: 'ignored',
         },
@@ -267,7 +267,7 @@ describe('ErrorTrackingList', () => {
       expect(actions.updateStatus).toHaveBeenCalledWith(
         expect.anything(),
         {
-          endpoint: '/project/test/-/error_tracking/3.json',
+          endpoint: `/project/test/-/error_tracking/${errorsList[0].id}.json`,
           redirectUrl: '/error_tracking',
           status: 'resolved',
         },

spec/frontend/error_tracking/store/details/actions_spec.js

@@ -26,53 +26,6 @@ describe('Sentry error details store actions', () => {
     }
   });
-  describe('startPollingDetails', () => {
-    const endpoint = '123/details';
-    it('should commit SET_ERROR with received response', done => {
-      const payload = { error: { id: 1 } };
-      mockedAdapter.onGet().reply(200, payload);
-      testAction(
-        actions.startPollingDetails,
-        { endpoint },
-        {},
-        [
-          { type: types.SET_ERROR, payload: payload.error },
-          { type: types.SET_LOADING, payload: false },
-        ],
-        [],
-        () => {
-          done();
-        },
-      );
-    });
-
-    it('should show flash on API error', done => {
-      mockedAdapter.onGet().reply(400);
-
-      testAction(
-        actions.startPollingDetails,
-        { endpoint },
-        {},
-        [{ type: types.SET_LOADING, payload: false }],
-        [],
-        () => {
-          expect(createFlash).toHaveBeenCalledTimes(1);
-          done();
-        },
-      );
-    });
-
-    it('should not restart polling when receiving an empty 204 response', done => {
-      mockedRestart = jest.spyOn(Poll.prototype, 'restart');
-      mockedAdapter.onGet().reply(204);
-
-      testAction(actions.startPollingDetails, { endpoint }, {}, [], [], () => {
-        expect(mockedRestart).toHaveBeenCalledTimes(0);
-        done();
-      });
-    });
-  });
-
   describe('startPollingStacktrace', () => {
     const endpoint = '123/stacktrace';
     it('should commit SET_ERROR with received response', done => {

spec/frontend/jobs/components/log/mock_data.js

@@ -34,7 +34,7 @@ export const utilsMockData = [
     content: [
       {
         text:
-          'Using Docker executor with image dev.gitlab.org:5005/gitlab/gitlab-build-images:ruby-2.6.5-golang-1.12-git-2.24-lfs-2.9-chrome-73.0-node-12.x-yarn-1.16-postgresql-9.6-graphicsmagick-1.3.33',
+          'Using Docker executor with image dev.gitlab.org:5005/gitlab/gitlab-build-images:ruby-2.6.5-golang-1.12-git-2.24-lfs-2.9-chrome-73.0-node-12.x-yarn-1.16-postgresql-9.6-graphicsmagick-1.3.34',
       },
     ],
     section: 'prepare-executor',

spec/helpers/projects/error_tracking_helper_spec.rb

@@ -83,7 +83,6 @@ describe Projects::ErrorTrackingHelper do
   describe '#error_details_data' do
     let(:issue_id) { 1234 }
     let(:route_params) { [project.owner, project, issue_id, { format: :json }] }
-    let(:details_path) { details_namespace_project_error_tracking_index_path(*route_params) }
     let(:project_path) { project.full_path }
     let(:stack_trace_path) { stack_trace_namespace_project_error_tracking_index_path(*route_params) }
     let(:issues_path) { project_issues_path(project) }
@@ -98,10 +97,6 @@ describe Projects::ErrorTrackingHelper do
       expect(result['project-path']).to eq project_path
     end
-    it 'returns the correct details path' do
-      expect(result['issue-details-path']).to eq details_path
-    end
-
     it 'returns the correct stack trace path' do
       expect(result['issue-stack-trace-path']).to eq stack_trace_path
     end

spec/lib/gitlab/kubernetes/generic_secret_spec.rb

+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Gitlab::Kubernetes::GenericSecret do
+  let(:secret) { described_class.new(name, data, namespace) }
+  let(:name) { 'example-name' }
+  let(:data) { 'example-data' }
+  let(:namespace) { 'example-namespace' }
+
+  describe '#generate' do
+    subject { secret.generate }
+
+    let(:resource) do
+      ::Kubeclient::Resource.new(
+        type: 'Opaque',
+        metadata: { name: name, namespace: namespace },
+        data: data
+      )
+    end
+
+    it { is_expected.to eq(resource) }
+  end
+end

spec/lib/gitlab/kubernetes/tls_secret_spec.rb

+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Gitlab::Kubernetes::TlsSecret do
+  let(:secret) { described_class.new(name, cert, key, namespace) }
+  let(:name) { 'example-name' }
+  let(:cert) { 'example-cert' }
+  let(:key) { 'example-key' }
+  let(:namespace) { 'example-namespace' }
+
+  let(:data) do
+    {
+      'tls.crt': Base64.strict_encode64(cert),
+      'tls.key': Base64.strict_encode64(key)
+    }
+  end
+
+  describe '#generate' do
+    subject { secret.generate }
+
+    let(:resource) do
+      ::Kubeclient::Resource.new(
+        type: 'kubernetes.io/tls',
+        metadata: { name: name, namespace: namespace },
+        data: data
+      )
+    end
+
+    it { is_expected.to eq(resource) }
+  end
+end

spec/lib/gitlab/utils/deep_size_spec.rb

@@ -17,29 +17,45 @@ describe Gitlab::Utils::DeepSize do
   let(:max_size) { 1.kilobyte }
   let(:max_depth) { 10 }
-  let(:deep_size) { described_class.new(data, max_size: max_size, max_depth: max_depth) }
-  describe '#evaluate' do
-    context 'when data within size and depth limits' do
-      it 'returns true' do
-        expect(deep_size).to be_valid
+  subject(:deep_size) { described_class.new(data, max_size: max_size, max_depth: max_depth) }
+
+  it { expect(described_class::DEFAULT_MAX_SIZE).to eq(1.megabyte) }
+  it { expect(described_class::DEFAULT_MAX_DEPTH).to eq(100) }
+
+  describe '#initialize' do
+    context 'when max_size is nil' do
+      let(:max_size) { nil }
+
+      it 'sets max_size to DEFAULT_MAX_SIZE' do
+        expect(subject.instance_variable_get(:@max_size)).to eq(described_class::DEFAULT_MAX_SIZE)
+      end
+    end
+
+    context 'when max_depth is nil' do
+      let(:max_depth) { nil }
+
+      it 'sets max_depth to DEFAULT_MAX_DEPTH' do
+        expect(subject.instance_variable_get(:@max_depth)).to eq(described_class::DEFAULT_MAX_DEPTH)
       end
     end
+  end
+
+  describe '#valid?' do
+    context 'when data within size and depth limits' do
+      it { is_expected.to be_valid }
+    end
     context 'when data not within size limit' do
       let(:max_size) { 200.bytes }
-      it 'returns false' do
-        expect(deep_size).not_to be_valid
-      end
+      it { is_expected.not_to be_valid }
     end
     context 'when data not within depth limit' do
       let(:max_depth) { 2 }
-      it 'returns false' do
-        expect(deep_size).not_to be_valid
-      end
+      it { is_expected.not_to be_valid }
     end
   end

spec/models/serverless/domain_cluster_spec.rb

@@ -50,4 +50,12 @@ describe ::Serverless::DomainCluster do
   describe 'domain' do
     it { is_expected.to respond_to(:domain) }
   end
+
+  describe 'certificate' do
+    it { is_expected.to respond_to(:certificate) }
+  end
+
+  describe 'key' do
+    it { is_expected.to respond_to(:key) }
+  end
 end

spec/services/clusters/kubernetes/configure_istio_ingress_service_spec.rb

+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Clusters::Kubernetes::ConfigureIstioIngressService, '#execute' do
+  include KubernetesHelpers
+
+  let(:cluster) { create(:cluster, :project, :provided_by_gcp) }
+  let(:api_url) { 'https://kubernetes.example.com' }
+  let(:project) { cluster.project }
+  let(:environment) { create(:environment, project: project) }
+  let(:cluster_project) { cluster.cluster_project }
+  let(:namespace) { "#{project.name}-#{project.id}-#{environment.slug}" }
+  let(:kubeclient) { cluster.kubeclient }
+
+  subject do
+    described_class.new(
+      cluster: cluster
+    ).execute
+  end
+
+  before do
+    stub_kubeclient_discover_istio(api_url)
+    stub_kubeclient_create_secret(api_url, namespace: namespace)
+    stub_kubeclient_put_secret(api_url, "#{namespace}-token", namespace: namespace)
+
+    stub_kubeclient_get_secret(
+      api_url,
+      {
+        metadata_name: "#{namespace}-token",
+        token: Base64.encode64('sample-token'),
+        namespace: namespace
+      }
+    )
+
+    stub_kubeclient_get_secret(
+      api_url,
+      {
+        metadata_name: 'istio-ingressgateway-ca-certs',
+        namespace: 'istio-system'
+      }
+    )
+
+    stub_kubeclient_get_secret(
+      api_url,
+      {
+        metadata_name: 'istio-ingressgateway-certs',
+        namespace: 'istio-system'
+      }
+    )
+
+    stub_kubeclient_put_secret(api_url, 'istio-ingressgateway-ca-certs', namespace: 'istio-system')
+    stub_kubeclient_put_secret(api_url, 'istio-ingressgateway-certs', namespace: 'istio-system')
+    stub_kubeclient_get_gateway(api_url, 'knative-ingress-gateway', namespace: 'knative-serving')
+    stub_kubeclient_put_gateway(api_url, 'knative-ingress-gateway', namespace: 'knative-serving')
+  end
+
+  context 'without a serverless_domain_cluster' do
+    it 'configures gateway to use PASSTHROUGH' do
+      subject
+
+      expect(WebMock).to have_requested(:put, api_url + '/apis/networking.istio.io/v1alpha3/namespaces/knative-serving/gateways/knative-ingress-gateway').with(
+        body: hash_including(
+          apiVersion: "networking.istio.io/v1alpha3",
+          kind: "Gateway",
+          metadata: {
+            generation: 1,
+            labels: {
+              "networking.knative.dev/ingress-provider" => "istio",
+              "serving.knative.dev/release" => "v0.7.0"
+            },
+            name: "knative-ingress-gateway",
+            namespace: "knative-serving",
+            selfLink: "/apis/networking.istio.io/v1alpha3/namespaces/knative-serving/gateways/knative-ingress-gateway"
+          },
+          spec: {
+            selector: {
+              istio: "ingressgateway"
+            },
+            servers: [
+              {
+                hosts: ["*"],
+                port: {
+                  name: "http",
+                  number: 80,
+                  protocol: "HTTP"
+                }
+              },
+              {
+                hosts: ["*"],
+                port: {
+                  name: "https",
+                  number: 443,
+                  protocol: "HTTPS"
+                },
+                tls: {
+                  mode: "PASSTHROUGH"
+                }
+              }
+            ]
+          }
+        )
+      )
+    end
+  end
+
+  context 'with a serverless_domain_cluster' do
+    let(:serverless_domain_cluster) { create(:serverless_domain_cluster) }
+    let(:certificate) { OpenSSL::X509::Certificate.new(serverless_domain_cluster.certificate) }
+
+    before do
+      cluster.application_knative = serverless_domain_cluster.knative
+    end
+
+    it 'configures certificates' do
+      subject
+
+      expect(serverless_domain_cluster.reload.key).not_to be_blank
+      expect(serverless_domain_cluster.reload.certificate).not_to be_blank
+
+      expect(certificate.subject.to_s).to include(serverless_domain_cluster.knative.hostname)
+
+      expect(certificate.not_before).to be_within(1.minute).of(Time.now)
+      expect(certificate.not_after).to be_within(1.minute).of(Time.now + 1000.years)
+
+      expect(WebMock).to have_requested(:put, api_url + '/api/v1/namespaces/istio-system/secrets/istio-ingressgateway-ca-certs').with(
+        body: hash_including(
+          metadata: {
+            name: 'istio-ingressgateway-ca-certs',
+            namespace: 'istio-system'
+          },
+          type: 'Opaque'
+        )
+      )
+
+      expect(WebMock).to have_requested(:put, api_url + '/api/v1/namespaces/istio-system/secrets/istio-ingressgateway-certs').with(
+        body: hash_including(
+          metadata: {
+            name: 'istio-ingressgateway-certs',
+            namespace: 'istio-system'
+          },
+          type: 'kubernetes.io/tls'
+        )
+      )
+    end
+
+    it 'configures gateway to use MUTUAL' do
+      subject
+
+      expect(WebMock).to have_requested(:put, api_url + '/apis/networking.istio.io/v1alpha3/namespaces/knative-serving/gateways/knative-ingress-gateway').with(
+        body: {
+          apiVersion: "networking.istio.io/v1alpha3",
+          kind: "Gateway",
+          metadata: {
+            generation: 1,
+            labels: {
+              "networking.knative.dev/ingress-provider" => "istio",
+              "serving.knative.dev/release" => "v0.7.0"
+            },
+            name: "knative-ingress-gateway",
+            namespace: "knative-serving",
+            selfLink: "/apis/networking.istio.io/v1alpha3/namespaces/knative-serving/gateways/knative-ingress-gateway"
+          },
+          spec: {
+            selector: {
+              istio: "ingressgateway"
+            },
+            servers: [
+              {
+                hosts: ["*"],
+                port: {
+                  name: "http",
+                  number: 80,
+                  protocol: "HTTP"
+                }
+              },
+              {
+                hosts: ["*"],
+                port: {
+                  name: "https",
+                  number: 443,
+                  protocol: "HTTPS"
+                },
+                tls: {
+                  mode: "MUTUAL",
+                  privateKey: "/etc/istio/ingressgateway-certs/tls.key",
+                  serverCertificate: "/etc/istio/ingressgateway-certs/tls.crt",
+                  caCertificates: "/etc/istio/ingressgateway-ca-certs/cert.pem"
+                }
+              }
+            ]
+          }
+        }
+      )
+    end
+  end
+end

spec/services/snippets/count_service_spec.rb

+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Snippets::CountService do
+  let_it_be(:user) { create(:user) }
+  let_it_be(:project) { create(:project, :public) }
+
+  describe '#new' do
+    it 'raises an error if no author or project' do
+      expect { described_class.new(user) }.to raise_error(ArgumentError)
+    end
+
+    it 'uses the SnippetsFinder to scope snippets by user' do
+      expect(SnippetsFinder)
+        .to receive(:new)
+        .with(user, author: user, project: nil)
+
+      described_class.new(user, author: user)
+    end
+
+    it 'allows scoping to project' do
+      expect(SnippetsFinder)
+        .to receive(:new)
+        .with(user, author: nil, project: project)
+
+      described_class.new(user, project: project)
+    end
+  end
+
+  describe '#execute' do
+    subject { described_class.new(user, author: user).execute }
+
+    it 'returns a hash of counts' do
+      expect(subject).to match({
+        are_public: 0,
+        are_internal: 0,
+        are_private: 0,
+        are_public_or_internal: 0,
+        total: 0
+      })
+    end
+
+    it 'only counts snippets the user has access to' do
+      create(:personal_snippet, :private, author: user)
+      create(:project_snippet, :private, author: user)
+      create(:project_snippet, :private, author: create(:user))
+
+      expect(subject).to match({
+        are_public: 0,
+        are_internal: 0,
+        are_private: 1,
+        are_public_or_internal: 0,
+        total: 1
+      })
+    end
+
+    it 'returns an empty hash if select returns nil' do
+      allow_next_instance_of(described_class) do |instance|
+        allow(instance).to receive(:snippet_counts).and_return(nil)
+      end
+
+      expect(subject).to match({})
+    end
+  end
+end

spec/support/shared_examples/features/snippets_shared_examples.rb

@@ -18,3 +18,35 @@ RSpec.shared_examples 'paginated snippets' do |remote: false|
     end
   end
 end
+
+RSpec.shared_examples 'tabs with counts' do
+  let(:tabs) { page.all('.snippet-scope-menu li') }
+
+  it 'shows a tab for All snippets and count' do
+    tab = tabs[0]
+
+    expect(tab.text).to include('All')
+    expect(tab.find('.badge').text).to eq(counts[:all])
+  end
+
+  it 'shows a tab for Private snippets and count' do
+    tab = tabs[1]
+
+    expect(tab.text).to include('Private')
+    expect(tab.find('.badge').text).to eq(counts[:private])
+  end
+
+  it 'shows a tab for Internal snippets and count' do
+    tab = tabs[2]
+
+    expect(tab.text).to include('Internal')
+    expect(tab.find('.badge').text).to eq(counts[:internal])
+  end
+
+  it 'shows a tab for Public snippets and count' do
+    tab = tabs[3]
+
+    expect(tab.text).to include('Public')
+    expect(tab.find('.badge').text).to eq(counts[:public])
+  end
+end

spec/workers/cluster_configure_istio_worker_spec.rb

+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ClusterConfigureIstioWorker do
+  describe '#perform' do
+    shared_examples 'configure istio service' do
+      it 'configures istio' do
+        expect_any_instance_of(Clusters::Kubernetes::ConfigureIstioIngressService).to receive(:execute)
+
+        described_class.new.perform(cluster.id)
+      end
+    end
+
+    context 'when provider type is gcp' do
+      let(:cluster) { create(:cluster, :project, :provided_by_gcp) }
+
+      it_behaves_like 'configure istio service'
+    end
+
+    context 'when provider type is aws' do
+      let(:cluster) { create(:cluster, :project, :provided_by_aws) }
+
+      it_behaves_like 'configure istio service'
+    end
+
+    context 'when provider type is user' do
+      let(:cluster) { create(:cluster, :project, :provided_by_user) }
+
+      it_behaves_like 'configure istio service'
+    end
+
+    context 'when cluster does not exist' do
+      it 'does not provision a cluster' do
+        expect_any_instance_of(Clusters::Kubernetes::ConfigureIstioIngressService).not_to receive(:execute)
+
+        described_class.new.perform(123)
+      end
+    end
+  end
+end