WIP: Add Api::PublicProjectsController#create

Author: floehopper

app/controllers/api/public_projects_controller.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Api
+  class PublicProjectsController < ApiController
+    before_action :authorize_user
+
+    def create
+      result = PublicProject::Create.call(project_hash: project_params)
+
+      if result.success?
+        @project = result[:project]
+        render 'api/projects/show', formats: [:json], status: :created
+      else
+        render json: { error: result[:error] }, status: :unprocessable_entity
+      end
+    end
+
+    private
+
+    def project_params
+      params.fetch(:project, {}).permit(:identifier, :locale, :project_type, :name)
+    end
+  end
+end

config/routes.rb

@@ -41,6 +41,8 @@
       resource :images, only: %i[show create], controller: 'projects/images'
     end
 
+    resources :public_projects, only: %i[create]
+
     resource :project_errors, only: %i[create]
 
     resource :school, only: [:show], controller: 'my_school'

lib/concepts/public_project/operations/create.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class PublicProject
+  class Create
+    class << self
+      def call(project_hash:)
+        response = OperationResponse.new
+        response[:project] = build_project(project_hash)
+        response[:project].save!
+        response
+      rescue StandardError => e
+        Sentry.capture_exception(e)
+        response[:error] = "Error creating project: #{e}"
+        response
+      end
+
+      private
+
+      def build_project(project_hash)
+        Project.new(project_hash)
+      end
+    end
+  end
+end

spec/concepts/public_project/create_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe PublicProject::Create, type: :unit do
+  subject(:create_project) { described_class.call(project_hash:) }
+
+  describe '.call' do
+    let(:project_hash) { ActionController::Parameters.new({}) }
+
+    context 'with valid content' do
+      subject(:create_project_with_content) { described_class.call(project_hash:) }
+
+      let(:project_hash) do
+        {
+          identifier: 'foo-bar-baz',
+          locale: 'en',
+          project_type: Project::Types::SCRATCH,
+          name: 'Foo bar baz'
+        }
+      end
+
+      it 'returns success' do
+        expect(create_project_with_content.success?).to be(true)
+      end
+
+      it 'returns project with identifier' do
+        new_project = create_project_with_content[:project]
+        expect(new_project.identifier).to eq('foo-bar-baz')
+      end
+    end
+
+    context 'when creation fails' do
+      before do
+        mock_project = instance_double(Project)
+        allow(mock_project).to receive(:save!).and_raise('Some error')
+        allow(Project).to receive(:new).and_return(mock_project)
+        allow(Sentry).to receive(:capture_exception)
+      end
+
+      it 'returns failure' do
+        expect(create_project.failure?).to be(true)
+      end
+
+      it 'returns error message' do
+        expect(create_project[:error]).to eq('Error creating project: Some error')
+      end
+
+      it 'sent the exception to Sentry' do
+        create_project
+        expect(Sentry).to have_received(:capture_exception).with(kind_of(StandardError))
+      end
+    end
+  end
+end

spec/features/public_project/creating_a_public_project_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe 'Creating a public project', type: :request do
+  let(:creator) { build(:user) }
+  let(:headers) { { Authorization: UserProfileMock::TOKEN } }
+  let(:params) do
+    {
+      project: {
+        identifier: 'test-project',
+        locale: 'en',
+        project_type: Project::Types::SCRATCH,
+        name: 'Test Project'
+      }
+    }
+  end
+
+  before do
+    authenticated_in_hydra_as(creator)
+  end
+
+  it 'responds 201 Created' do
+    post('/api/public_projects', headers:, params:)
+    expect(response).to have_http_status(:created)
+  end
+
+  it 'responds with the project JSON' do
+    post('/api/public_projects', headers:, params:)
+    data = JSON.parse(response.body, symbolize_names: true)
+
+    expect(data).to include(
+      {
+        identifier: 'test-project',
+        locale: 'en',
+        project_type: Project::Types::SCRATCH,
+        name: 'Test Project'
+      }
+    )
+  end
+
+  it 'responds 422 Unprocessable Entity when params are invalid' do
+    post('/api/public_projects', headers:, params: { project: {} })
+    expect(response).to have_http_status(:unprocessable_entity)
+  end
+
+  it 'responds 401 Unauthorized when no token is given' do
+    post('/api/public_projects', params:)
+    expect(response).to have_http_status(:unauthorized)
+  end
+end

spec/requests/public_projects/create_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe 'Create public project requests' do
+  let(:project) { create(:project) }
+  let(:creator) { build(:user) }
+
+  context 'when auth is correct' do
+    let(:headers) { { Authorization: UserProfileMock::TOKEN } }
+
+    context 'when creating project is successful' do
+      before do
+        authenticated_in_hydra_as(creator)
+
+        response = OperationResponse.new
+        response[:project] = project
+        allow(PublicProject::Create).to receive(:call).and_return(response)
+      end
+
+      it 'returns success' do
+        post('/api/public_projects', headers:)
+
+        expect(response).to have_http_status(:created)
+      end
+    end
+
+    context 'when creating project fails' do
+      before do
+        authenticated_in_hydra_as(creator)
+
+        response = OperationResponse.new
+        response[:error] = 'Error creating project'
+        allow(PublicProject::Create).to receive(:call).and_return(response)
+      end
+
+      it 'returns error' do
+        post('/api/public_projects', headers:)
+
+        expect(response).to have_http_status(:unprocessable_entity)
+      end
+    end
+  end
+
+  context 'when no token is given' do
+    it 'returns unauthorized' do
+      post('/api/public_projects')
+
+      expect(response).to have_http_status(:unauthorized)
+    end
+  end
+end