test: combine methods of testing metadata (cloudfoundry#1933)

Removes previous patterns for testing metadata and replaces them with a new, more fluent method.

[#173082202](https://www.pivotaltracker.com/story/show/173082202)

Author: blgm

spec/request/app_manifests_spec.rb

@@ -107,10 +107,14 @@
 
       expect(app_model.service_bindings.length).to eq 1
       expect(app_model.service_bindings.first.service_instance).to eq service_instance
-      expect(app_model.labels.map { |label| { key: label.key_name, value: label.value } }).
-        to match_array([{ key: 'potato', value: 'yam' }, { key: 'songs', value: 'missing' }])
-      expect(app_model.annotations.map { |a| { key: a.key, value: a.value } }).
-        to match_array([{ key: 'potato', value: 'idaho' }, { key: 'juice', value: 'newton' }])
+      expect(app_model).to have_labels(
+        { key: 'potato', value: 'yam' },
+        { prefix: 'myspace.com', key: 'songs', value: 'missing' },
+      )
+      expect(app_model).to have_annotations(
+        { key: 'potato', value: 'idaho' },
+        { key: 'juice', value: 'newton' },
+      )
     end
 
     context 'sidecars' do

spec/request/deployments_spec.rb

@@ -294,8 +294,13 @@
         expect(last_response.status).to eq(201)
 
         deployment = VCAP::CloudController::DeploymentModel.last
-        expect(deployment.labels.map(&:value)).to contain_exactly('stable', 'mashed')
-        expect(deployment.annotations.map(&:value)).to contain_exactly('idaho')
+        expect(deployment).to have_labels(
+          { prefix: 'seriouseats.com', key: 'potato', value: 'mashed' },
+          { prefix: nil, key: 'release', value: 'stable' }
+        )
+        expect(deployment).to have_annotations(
+          { key: 'potato', value: 'idaho' },
+        )
 
         expect(parsed_response).to be_a_response_like({
           'guid' => deployment.guid,

spec/request/service_instances_spec.rb

@@ -847,12 +847,8 @@ def check_filtered_instances(*instances)
         expect(instance.tags).to contain_exactly('foo', 'bar', 'baz')
         expect(instance.credentials).to match({ 'foo' => 'bar', 'baz' => 'qux' })
         expect(instance.space).to eq(space)
-
-        expect_metadata(
-          instance,
-          annotations: [{ prefix: nil, key: 'foo', value: 'bar' }],
-          labels: [{ prefix: nil, key: 'baz', value: 'qux' }]
-        )
+        expect(instance).to have_annotations({ prefix: nil, key: 'foo', value: 'bar' })
+        expect(instance).to have_labels({ prefix: nil, key: 'baz', value: 'qux' })
       end
 
       context 'when the name has already been taken' do
@@ -946,11 +942,8 @@ def check_filtered_instances(*instances)
         expect(instance.space).to eq(space)
         expect(instance.service_plan).to eq(service_plan)
 
-        expect_metadata(
-          instance,
-          annotations: [{ prefix: nil, key: 'foo', value: 'bar' }],
-          labels: [{ prefix: nil, key: 'baz', value: 'qux' }]
-        )
+        expect(instance).to have_annotations({ prefix: nil, key: 'foo', value: 'bar' })
+        expect(instance).to have_labels({ prefix: nil, key: 'baz', value: 'qux' })
 
         expect(instance.last_operation.type).to eq('create')
         expect(instance.last_operation.state).to eq('in progress')
@@ -1580,18 +1573,15 @@ def check_filtered_instances(*instances)
           service_instance.reload
           expect(service_instance.tags).to eq(%w(baz quz))
 
-          expect_metadata(
-            service_instance,
-            annotations: [
-              { prefix: 'pre.fix', key: 'fox', value: 'bushy' },
-              { prefix: nil, key: 'potato', value: 'idaho' },
-              { prefix: nil, key: 'style', value: 'mashed' },
-            ],
-            labels: [
-              { prefix: 'pre.fix', key: 'tail', value: 'fluffy' },
-              { prefix: nil, key: 'potato', value: 'yam' },
-              { prefix: nil, key: 'style', value: 'baked' }
-            ]
+          expect(service_instance).to have_annotations(
+            { prefix: 'pre.fix', key: 'fox', value: 'bushy' },
+            { prefix: nil, key: 'potato', value: 'idaho' },
+            { prefix: nil, key: 'style', value: 'mashed' },
+          )
+          expect(service_instance).to have_labels(
+            { prefix: 'pre.fix', key: 'tail', value: 'fluffy' },
+            { prefix: nil, key: 'potato', value: 'yam' },
+            { prefix: nil, key: 'style', value: 'baked' }
           )
 
           expect(service_instance.last_operation.type).to eq('update')
@@ -1684,16 +1674,13 @@ def check_filtered_instances(*instances)
           service_instance.reload
           expect(service_instance.reload.tags).to eq(%w(foo bar))
 
-          expect_metadata(
-            service_instance,
-            annotations: [
-              { prefix: 'pre.fix', key: 'to_delete', value: 'value' },
-              { prefix: 'pre.fix', key: 'fox', value: 'bushy' },
-            ],
-            labels: [
-              { prefix: 'pre.fix', key: 'to_delete', value: 'value' },
-              { prefix: 'pre.fix', key: 'tail', value: 'fluffy' }
-            ]
+          expect(service_instance).to have_annotations(
+            { prefix: 'pre.fix', key: 'to_delete', value: 'value' },
+            { prefix: 'pre.fix', key: 'fox', value: 'bushy' },
+          )
+          expect(service_instance).to have_labels(
+            { prefix: 'pre.fix', key: 'to_delete', value: 'value' },
+            { prefix: 'pre.fix', key: 'tail', value: 'fluffy' }
           )
         end
 
@@ -1921,16 +1908,13 @@ def check_filtered_instances(*instances)
                 service_instance.reload
                 expect(service_instance.reload.tags).to eq(%w(foo bar))
                 expect(service_instance.service_plan).to eq(original_service_plan)
-                expect_metadata(
-                  service_instance,
-                  annotations: [
-                    { prefix: 'pre.fix', key: 'to_delete', value: 'value' },
-                    { prefix: 'pre.fix', key: 'fox', value: 'bushy' },
-                  ],
-                  labels: [
-                    { prefix: 'pre.fix', key: 'to_delete', value: 'value' },
-                    { prefix: 'pre.fix', key: 'tail', value: 'fluffy' }
-                  ]
+                expect(service_instance).to have_annotations(
+                  { prefix: 'pre.fix', key: 'to_delete', value: 'value' },
+                  { prefix: 'pre.fix', key: 'fox', value: 'bushy' },
+                )
+                expect(service_instance).to have_labels(
+                  { prefix: 'pre.fix', key: 'to_delete', value: 'value' },
+                  { prefix: 'pre.fix', key: 'tail', value: 'fluffy' }
                 )
               end
 
@@ -2506,10 +2490,10 @@ def check_filtered_instances(*instances)
       let(:guid) { service_instance.guid }
       let(:request_body) {
         {
-            metadata: {
-                labels: { unit: 'metre', distance: '1003' },
-                annotations: { location: 'london' }
-            }
+          metadata: {
+            labels: { unit: 'metre', distance: '1003' },
+            annotations: { location: 'london' }
+          }
         }
       }
 
@@ -2525,10 +2509,10 @@ def check_filtered_instances(*instances)
           api_call.call(admin_headers)
           expect(last_response).to have_status_code(200)
           expect(parsed_response['last_operation']).to include({
-                                                                   'type' => 'create',
-                                                                   'state' => 'in progress',
-                                                                   'description' => 'almost there, I promise'
-                                                               })
+            'type' => 'create',
+            'state' => 'in progress',
+            'description' => 'almost there, I promise'
+          })
         end
       end
 
@@ -3866,27 +3850,6 @@ def create_user_provided_json(instance, labels: {}, annotations: {})
     }
   end
 
-  def expect_metadata(instance, annotations: [], labels: [])
-    a = instance.annotations.map do |e|
-      {
-        prefix: e.key_prefix,
-        key: e.key_name,
-        value: e.value,
-      }
-    end
-
-    l = instance.labels.map do |e|
-      {
-        prefix: e.key_prefix,
-        key: e.key_name,
-        value: e.value,
-      }
-    end
-
-    expect(a).to match_array(annotations)
-    expect(l).to match_array(labels)
-  end
-
   def share_service_instance(instance, target_space)
     enable_sharing!
 

spec/request/space_manifests_spec.rb

@@ -140,10 +140,8 @@
 
       expect(app1_model.service_bindings.length).to eq 1
       expect(app1_model.service_bindings.first.service_instance).to eq service_instance
-      expect(app1_model.labels.map { |label| { key: label.key_name, value: label.value } }).
-        to match_array([{ key: 'potato', value: 'yam' }, { key: 'songs', value: 'missing' }])
-      expect(app1_model.annotations.map { |a| { key: a.key, value: a.value } }).
-        to match_array([{ key: 'potato', value: 'idaho' }, { key: 'juice', value: 'newton' }])
+      expect(app1_model).to have_labels({ key: 'potato', value: 'yam' }, { prefix: 'myspace.com', key: 'songs', value: 'missing' })
+      expect(app1_model).to have_annotations({ key: 'potato', value: 'idaho' }, { key: 'juice', value: 'newton' })
 
       app2_model.reload
       lifecycle_data = app2_model.lifecycle_data
@@ -158,10 +156,12 @@
 
       expect(app2_model.service_bindings.length).to eq 1
       expect(app2_model.service_bindings.first.service_instance).to eq service_instance
-      expect(app2_model.labels.map { |label| { key: label.key_name, value: label.value } }).
-        to match_array([{ key: 'potato', value: 'yam' },])
-      expect(app2_model.annotations.map { |a| { key: a.key, value: a.value } }).
-        to match_array([{ key: 'potato', value: 'idaho' }, { key: 'juice', value: 'newton' },])
+      expect(app2_model).to have_labels(
+        { key: 'potato', value: 'yam' }
+      )
+      expect(app2_model).to have_annotations(
+        { key: 'potato', value: 'idaho' }, { key: 'juice', value: 'newton' }
+      )
     end
 
     context 'service bindings' do

spec/support/matchers/contain_metadata.rb

@@ -0,0 +1,47 @@
+RSpec::Matchers.define :have_annotations do |*expected|
+  actual_annotations = []
+
+  match do |actual|
+    actual_annotations = actual.annotations.map do |annotation|
+      {
+        prefix: annotation.key_prefix,
+        key: annotation.key_name,
+        value: annotation.value,
+      }
+    end
+
+    if expected.any?
+      expected = expected.map do |annotation|
+        {
+          prefix: annotation.with_indifferent_access[:prefix],
+          key: annotation.with_indifferent_access[:key],
+          value: annotation.with_indifferent_access[:value],
+        }
+      end
+
+      expect(actual_annotations).to match_array(expected)
+    else # Situation: expect(thing).to have_annotations
+      expect(actual_annotations).not_to be_empty
+    end
+  end
+
+  failure_message do
+    if expected.any?
+      [
+        "Annotations don't match!",
+        "Expected #{expected}",
+        "     got #{actual_annotations}",
+      ].join("\n")
+    else
+      'Expected annotations but found none!'
+    end
+  end
+
+  failure_message_when_negated do
+    if expected.any?
+      "Annotations unexpectedly match: got #{actual_annotations}"
+    else
+      "Expected no annotations but got #{actual_annotations}"
+    end
+  end
+end

spec/support/matchers/have_annotations.rb

@@ -0,0 +1,47 @@
+RSpec::Matchers.define :have_labels do |*expected|
+  actual_labels = []
+
+  match do |actual|
+    actual_labels = actual.labels.map do |label|
+      {
+        prefix: label.key_prefix,
+        key: label.key_name,
+        value: label.value,
+      }
+    end
+
+    if expected.any?
+      expected = expected.map do |label|
+        {
+          prefix: label.with_indifferent_access[:prefix],
+          key: label.with_indifferent_access[:key],
+          value: label.with_indifferent_access[:value],
+        }
+      end
+
+      expect(actual_labels).to match_array(expected)
+    else # Situation: expect(thing).to have_labels
+      expect(actual_labels).not_to be_empty
+    end
+  end
+
+  failure_message do
+    if expected.any?
+      [
+        "Labels don't match!",
+        "Expected #{expected}",
+        "     got #{actual_labels}",
+      ].join("\n")
+    else
+      'Expected labels but found none!'
+    end
+  end
+
+  failure_message_when_negated do
+    if expected.any?
+      "Labels unexpectedly match: got #{actual_labels}"
+    else
+      "Expected no labels but got #{actual_labels}"
+    end
+  end
+end

spec/support/matchers/have_labels.rb

@@ -49,8 +49,15 @@ module VCAP::CloudController
           expect(app.name).to eq('my-app')
           expect(app.space).to eq(space)
           expect(app.environment_variables).to eq(environment_variables.stringify_keys)
-          expect(app.labels.map(&:value)).to contain_exactly('stable', 'mashed')
-          expect(app.annotations.map(&:value)).to contain_exactly('Bummer-boy', 'Bums you out')
+
+          expect(app).to have_labels(
+            { prefix: 'seriouseats.com', key: 'potato', value: 'mashed' },
+            { prefix: nil, key: 'release', value: 'stable' }
+          )
+          expect(app).to have_annotations(
+            { key: 'superhero', value: 'Bummer-boy' },
+            { key: 'superpower', value: 'Bums you out' }
+          )
         end
 
         describe 'created process' do

spec/unit/actions/app_create_spec.rb

@@ -193,9 +193,9 @@ module VCAP::CloudController
 
         it 'updates the annotations' do
           app_update.update(app_model, message, lifecycle)
-          expect(app_model.annotations.map(&:value)).to contain_exactly(
-            'Bill tel(1111111) email(bill@fixme), Bob tel(222222) pager(3333333#555) email(bob@fixme)',
-            'new-value'
+          expect(app_model).to have_annotations(
+            { key: 'contacts', value: 'Bill tel(1111111) email(bill@fixme), Bob tel(222222) pager(3333333#555) email(bob@fixme)' },
+            { key: 'existing_anno', value: 'new-value' },
           )
           expect(AppAnnotationModel.find(resource_guid: app_model.guid, key: 'please')).to be_nil
         end