summaryrefslogtreecommitdiff
path: root/spec/controllers/projects/imports_controller_spec.rb
blob: bdc81efe3bc7cf4db6c0b9d66512e9c2d605ed45 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
# frozen_string_literal: true

require 'spec_helper'

describe Projects::ImportsController do
  let(:user) { create(:user) }
  let(:project) { create(:project) }

  before do
    sign_in(user)
    project.add_maintainer(user)
  end

  describe 'GET #show' do
    context 'when repository does not exists' do
      it 'renders template' do
        get :show, params: { namespace_id: project.namespace.to_param, project_id: project }

        expect(response).to render_template :show
      end

      it 'sets flash.now if params is present' do
        get :show, params: { namespace_id: project.namespace.to_param, project_id: project, continue: { to: '/', notice_now: 'Started' } }

        expect(flash.now[:notice]).to eq 'Started'
      end
    end

    context 'when repository exists' do
      let(:project) { create(:project_empty_repo, import_url: 'https://github.com/vim/vim.git') }
      let(:import_state) { project.import_state }

      context 'when import is in progress' do
        before do
          import_state.update(status: :started)
        end

        it 'renders template' do
          get :show, params: { namespace_id: project.namespace.to_param, project_id: project }

          expect(response).to render_template :show
        end

        it 'sets flash.now if params is present' do
          get :show, params: { namespace_id: project.namespace.to_param, project_id: project, continue: { to: '/', notice_now: 'In progress' } }

          expect(flash.now[:notice]).to eq 'In progress'
        end
      end

      context 'when import failed' do
        before do
          import_state.update(status: :failed)
        end

        it 'redirects to new_namespace_project_import_path' do
          get :show, params: { namespace_id: project.namespace.to_param, project_id: project }

          expect(response).to redirect_to new_project_import_path(project)
        end
      end

      context 'when import finished' do
        before do
          import_state.update(status: :finished)
        end

        context 'when project is a fork' do
          it 'redirects to namespace_project_path' do
            allow_any_instance_of(Project).to receive(:forked?).and_return(true)

            get :show, params: { namespace_id: project.namespace.to_param, project_id: project }

            expect(flash[:notice]).to eq 'The project was successfully forked.'
            expect(response).to redirect_to project_path(project)
          end
        end

        context 'when project is external' do
          it 'redirects to namespace_project_path' do
            get :show, params: { namespace_id: project.namespace.to_param, project_id: project }

            expect(flash[:notice]).to eq 'The project was successfully imported.'
            expect(response).to redirect_to project_path(project)
          end
        end

        context 'when continue params is present' do
          let(:params) do
            {
              to: project_path(project),
              notice: 'Finished'
            }
          end

          it 'redirects to internal params[:to]' do
            get :show, params: { namespace_id: project.namespace.to_param, project_id: project, continue: params }

            expect(flash[:notice]).to eq params[:notice]
            expect(response).to redirect_to params[:to]
          end

          it 'does not redirect to external params[:to]' do
            params[:to] = "//google.com"

            get :show, params: { namespace_id: project.namespace.to_param, project_id: project, continue: params }
            expect(response).not_to redirect_to params[:to]
          end
        end
      end

      context 'when import never happened' do
        before do
          import_state.update(status: :none)
        end

        it 'redirects to namespace_project_path' do
          get :show, params: { namespace_id: project.namespace.to_param, project_id: project }

          expect(response).to redirect_to project_path(project)
        end
      end
    end
  end

  describe 'POST #create' do
    let(:params) { { import_url: 'https://github.com/vim/vim.git', import_url_user: 'user', import_url_password: 'password' } }
    let(:project) { create(:project) }

    before do
      allow(RepositoryImportWorker).to receive(:perform_async)

      post :create, params: { project: params, namespace_id: project.namespace.to_param, project_id: project }
    end

    it 'sets import_url to the project' do
      expect(project.reload.import_url).to eq('https://user:password@github.com/vim/vim.git')
    end
  end
end