Add unit tests

Co-authored-by: Ralf Pannemans <ralf.pannemans@sap.com>
Co-authored-by: Johannes Dillmann <j.dillmann@sap.com>
Co-authored-by: Nicolas Bender <nicolas.bender@sap.com>

lib/cloud_controller/diego/failure_reason_sanitizer.rb

@@ -32,6 +32,7 @@ module DiegoErrors
     end
 
     class FailureReasonSanitizer
+      # rubocop:disable Metrics/CyclomaticComplexity
       def self.sanitize(message)
         staging_failed = 'staging failed'
         id = CCMessages::STAGING_ERROR
@@ -84,6 +85,7 @@ def self.sanitize(message)
           message:
         }
       end
+      # rubocop:enable Metrics/CyclomaticComplexity
     end
   end
 end

spec/request/app_manifests_spec.rb

@@ -90,6 +90,7 @@
                 'one' => 'tomato',
                 'two' => 'potato'
               },
+              'lifecycle' => 'buildpack',
               'buildpacks' => [buildpack.name, buildpack2.name],
               'stack' => buildpack.stack,
               'services' => [service_binding.service_instance_name, service_binding2.service_instance_name],
@@ -191,6 +192,7 @@
                 'one' => 'tomato',
                 'two' => 'potato'
               },
+              'lifecycle' => 'docker',
               'docker' => {
                 'image' => docker_package.image,
                 'username' => 'xXxMyL1ttlePwnyxXx'
@@ -266,6 +268,7 @@
           'applications' => [
             {
               'name' => simple_app.name,
+              'lifecycle' => 'buildpack',
               'stack' => 'itaewon_class_best_kdrama',
               'routes' => [
                 {

spec/support/fakes/blueprints.rb

@@ -112,6 +112,14 @@ module VCAP::CloudController
     sha256_checksum { Sham.guid }
   end
 
+  PackageModel.blueprint(:cnb) do
+    guid     { Sham.guid }
+    state    { VCAP::CloudController::PackageModel::CREATED_STATE }
+    type     { 'bits' }
+    app { AppModel.make(:cnb) }
+    sha256_checksum { Sham.guid }
+  end
+
   PackageModel.blueprint(:docker) do
     guid     { Sham.guid }
     state    { VCAP::CloudController::PackageModel::READY_STATE }
@@ -148,8 +156,9 @@ module VCAP::CloudController
 
   DropletModel.blueprint(:cnb) do
     guid { Sham.guid }
-    droplet_hash { nil }
-    sha256_checksum { nil }
+    droplet_hash { Sham.guid }
+    sha256_checksum { Sham.guid }
+    process_types { { 'web' => '$HOME/boot.sh' } }
     state { VCAP::CloudController::DropletModel::STAGED_STATE }
     app { AppModel.make(:cnb, droplet_guid: guid) }
     cnb_lifecycle_data { CNBLifecycleDataModel.make(droplet: object.save) }
@@ -207,6 +216,19 @@ module VCAP::CloudController
     failure_reason {}
   end
 
+  TaskModel.blueprint(:cnb) do
+    guid { Sham.guid }
+    app { AppModel.make(:cnb) }
+    name { Sham.name }
+    droplet { DropletModel.make(:cnb, app:) }
+    command { 'bundle exec rake' }
+    state { VCAP::CloudController::TaskModel::RUNNING_STATE }
+    memory_in_mb { 256 }
+    disk_in_mb {}
+    sequence_id { Sham.sequence_id }
+    failure_reason {}
+  end
+
   TaskModel.blueprint(:running) do
     guid { Sham.guid }
     app { AppModel.make }
@@ -470,6 +492,14 @@ module VCAP::CloudController
     metadata { {} }
   end
 
+  ProcessModel.blueprint(:cnb) do
+    instances { 1 }
+    type { 'web' }
+    diego { true }
+    app { AppModel.make(:cnb) }
+    metadata { {} }
+  end
+
   ProcessModel.blueprint(:diego_runnable) do
     app { AppModel.make(droplet: DropletModel.make) }
     diego { true }

spec/unit/actions/app_apply_manifest_spec.rb

@@ -117,6 +117,17 @@ module VCAP::CloudController
               expect(app_update).to have_received(:update).
                 with(app, app_update_message, instance_of(AppBuildpackLifecycle))
             end
+
+            describe 'using cnb type' do
+              let(:app) { AppModel.make(:cnb) }
+
+              it 'calls AppUpdate with the correct arguments' do
+                app_apply_manifest.apply(app.guid, message)
+                expect(AppUpdate).to have_received(:new).with(user_audit_info, manifest_triggered: true)
+                expect(app_update).to have_received(:update).
+                  with(app, app_update_message, instance_of(AppCNBLifecycle))
+              end
+            end
           end
 
           context 'when the request is invalid due to failure to update the app' do

spec/unit/actions/app_create_spec.rb

@@ -139,6 +139,18 @@ module VCAP::CloudController
         end
       end
 
+      describe 'cnb' do
+        let(:lifecycle_request) { { type: 'cnb', data: { stack: 'cflinuxfs4' } } }
+        let(:lifecycle) { AppCNBLifecycle.new(message) }
+
+        it 'creates app with lifecycle type cnb' do
+          expect do
+            app = app_create.create(message, lifecycle)
+            expect(app.lifecycle_type).to eq 'cnb'
+          end.to change(AppModel, :count).by(1)
+        end
+      end
+
       context 'when using a custom buildpack' do
         let(:buildpack_identifier) { 'https://github.com/buildpacks/my-special-buildpack' }
 

spec/unit/actions/build_create_spec.rb

@@ -171,6 +171,99 @@ module VCAP::CloudController
         end
       end
 
+      context 'creating a build for type cnb' do
+        let(:request_lifecycle) do
+          {
+            type: 'cnb',
+            data: lifecycle_data
+          }
+        end
+        let(:lifecycle) { CNBLifecycle.new(package, staging_message) }
+
+        it 'creates a build' do
+          build = nil
+
+          expect do
+            build = action.create_and_stage(package:, lifecycle:, metadata:)
+          end.to change(BuildModel, :count).by(1)
+
+          expect(build.state).to eq(BuildModel::STAGING_STATE)
+          expect(build.app_guid).to eq(app.guid)
+          expect(build.package_guid).to eq(package.guid)
+          expect(build.staging_memory_in_mb).to eq(calculated_mem_limit)
+          expect(build.staging_disk_in_mb).to eq(calculated_staging_disk_in_mb)
+          expect(build.staging_log_rate_limit).to eq(calculated_staging_log_rate_limit)
+          expect(build.lifecycle_data.to_hash).to eq(lifecycle_data)
+          expect(build.created_by_user_guid).to eq('1234')
+          expect(build.created_by_user_name).to eq('charles')
+          expect(build.created_by_user_email).to eq('charles@las.gym')
+          expect(build).to have_labels(
+            { prefix: nil, key_name: 'release', value: 'stable' },
+            { prefix: 'seriouseats.com', key_name: 'potato', value: 'mashed' }
+          )
+          expect(build).to have_annotations(
+            { key_name: 'anno', value: 'tations' }
+          )
+        end
+
+        it 'creates an app usage event for STAGING_STARTED' do
+          build = nil
+          expect do
+            build = action.create_and_stage(package:, lifecycle:, metadata:)
+          end.to change(AppUsageEvent, :count).by(1)
+
+          event = AppUsageEvent.last
+          expect(event).not_to be_nil
+          expect(event.state).to eq('STAGING_STARTED')
+          expect(event.previous_state).to eq('STAGING')
+          expect(event.instance_count).to eq(1)
+          expect(event.previous_instance_count).to eq(1)
+          expect(event.memory_in_mb_per_instance).to eq(BuildModel::STAGING_MEMORY)
+          expect(event.previous_memory_in_mb_per_instance).to eq(BuildModel::STAGING_MEMORY)
+
+          expect(event.org_guid).to eq(build.app.space.organization.guid)
+          expect(event.space_guid).to eq(build.app.space.guid)
+          expect(event.parent_app_guid).to eq(build.app.guid)
+          expect(event.parent_app_name).to eq(build.app.name)
+          expect(event.package_guid).to eq(build.package_guid)
+          expect(event.app_name).to eq('')
+          expect(event.app_guid).to eq('')
+          expect(event.package_state).to eq('READY')
+          expect(event.previous_package_state).to eq('READY')
+
+          expect(event.buildpack_guid).to be_nil
+          expect(event.buildpack_name).to eq(buildpack_git_url)
+        end
+
+        it 'creates a build audit event' do
+          build = action.create_and_stage(package:, lifecycle:, metadata:)
+          event = Event.last
+          expect(event.type).to eq('audit.app.build.create')
+          expect(event.actor).to eq('1234')
+          expect(event.actor_type).to eq('user')
+          expect(event.actor_name).to eq('charles@las.gym')
+          expect(event.actor_username).to eq('charles')
+          expect(event.actee).to eq(app.guid)
+          expect(event.actee_type).to eq('app')
+          expect(event.actee_name).to eq(app.name)
+          expect(event.timestamp).to be
+          expect(event.space_guid).to eq(app.space_guid)
+          expect(event.organization_guid).to eq(app.space.organization.guid)
+          expect(event.metadata).to eq({
+                                         'build_guid' => build.guid,
+                                         'package_guid' => package.guid
+                                       })
+        end
+
+        it 'does not create a droplet audit event' do
+          expect do
+            action.create_and_stage(package:, lifecycle:)
+          end.not_to(change do
+            Event.where(type: 'audit.app.droplet.create').count
+          end)
+        end
+      end
+
       describe 'creating a stage request' do
         it 'initiates a staging request' do
           build = action.create_and_stage(package:, lifecycle:)