deltacloud-core 0.5.0 → 1.0.0

data/tests/drivers/mock/buckets_test.rb

@@ -0,0 +1,195 @@
+$:.unshift File.join(File.dirname(__FILE__), '..', '..', '..')
+require 'tests/drivers/mock/common'
+
+describe 'Deltacloud API buckets' do
+  include Deltacloud::Test
+
+  it 'must advertise have the buckets collection in API entrypoint' do
+    get root_url
+    (xml_response/'api/link[@rel=buckets]').wont_be_empty
+  end
+
+  it 'must require authentication to access the "bucket" collection' do
+    get collection_url(:buckets)
+    last_response.status.must_equal 401
+  end
+
+  it 'should respond with HTTP_OK when accessing the :buckets collection with authentication' do
+    authenticate
+    get collection_url(:buckets)
+    last_response.status.must_equal 200
+  end
+
+  it 'should support the JSON media type' do
+    authenticate
+    header 'Accept', 'application/json'
+    get collection_url(:buckets)
+    last_response.status.must_equal 200
+    last_response.headers['Content-Type'].must_equal 'application/json'
+  end
+
+  it 'must include the ETag in HTTP headers' do
+    authenticate
+    get collection_url(:buckets)
+    last_response.headers['ETag'].wont_be_nil
+  end
+
+  it 'must have the "buckets" element on top level' do
+    authenticate
+    get collection_url(:buckets)
+    xml_response.root.name.must_equal 'buckets'
+  end
+
+  it 'must have some "bucket" elements inside "buckets"' do
+    authenticate
+    get collection_url(:buckets)
+    (xml_response/'buckets/bucket').wont_be_empty
+  end
+
+  it 'must provide the :id attribute for each bucket in collection' do
+    authenticate
+    get collection_url(:buckets)
+    (xml_response/'buckets/bucket').each do |r|
+      r[:id].wont_be_nil
+    end
+  end
+
+  it 'must include the :href attribute for each "bucket" element in collection' do
+    authenticate
+    get collection_url(:buckets)
+    (xml_response/'buckets/bucket').each do |r|
+      r[:href].wont_be_nil
+    end
+  end
+
+  it 'must use the absolute URL in each :href attribute' do
+    authenticate
+    get collection_url(:buckets)
+    (xml_response/'buckets/bucket').each do |r|
+      r[:href].must_match /^http/
+    end
+  end
+
+  it 'must have the URL ending with the :id of the bucket' do
+    authenticate
+    get collection_url(:buckets)
+    (xml_response/'buckets/bucket').each do |r|
+      r[:href].must_match /#{r[:id]}$/
+    end
+  end
+
+  it 'must return the list of valid parameters for the :index action' do
+    authenticate
+    options collection_url(:buckets) + '/index'
+    last_response.headers['Allow'].wont_be_nil
+  end
+
+  it 'must have the "name" element defined for each bucket in collection' do
+    authenticate
+    get collection_url(:buckets)
+    (xml_response/'buckets/bucket').each do |r|
+      (r/'name').wont_be_nil
+    end
+  end
+
+  it 'must have the "state" element defined for each bucket in collection' do
+    authenticate
+    get collection_url(:buckets)
+    (xml_response/'buckets/bucket').each do |r|
+      (r/'state').wont_be_nil
+    end
+  end
+
+  it 'must return the full "bucket" when following the URL in bucket element' do
+    authenticate
+    get collection_url(:buckets)
+    (xml_response/'buckets/bucket').each do |r|
+      get collection_url(:buckets) + '/' + r[:id]
+      last_response.status.must_equal 200
+    end
+  end
+
+  it 'must have the "name" element for the bucket and it should match with the one in collection' do
+    authenticate
+    get collection_url(:buckets)
+    (xml_response/'buckets/bucket').each do |r|
+      get collection_url(:buckets) + '/' + r[:id]
+      (xml_response/'name').wont_be_empty
+      (xml_response/'name').first.text.must_equal((r/'name').first.text)
+    end
+  end
+
+  it 'must have the "size" element for the bucket and it should match with the one in collection' do
+    authenticate
+    get collection_url(:buckets)
+    (xml_response/'buckets/bucket').each do |r|
+      get collection_url(:buckets) + '/' + r[:id]
+      (xml_response/'size').wont_be_empty
+      (xml_response/'size').first.text.must_equal((r/'size').first.text)
+    end
+  end
+
+  it 'must have the "blob" elements for the bucket and it should match with the ones in collection' do
+    authenticate
+    get collection_url(:buckets)
+    (xml_response/'buckets/bucket').each do |r|
+      get collection_url(:buckets) + '/' + r[:id]
+      (xml_response/'bucket/blob').wont_be_empty
+      (xml_response/'bucket/blob').each do |b|
+        b[:id].wont_be_nil
+        b[:href].wont_be_nil
+        b[:href].must_match /^http/
+        b[:href].must_match /#{r[:id]}\/#{b[:id]}$/
+      end
+    end
+  end
+
+  it 'must have the "blob" elements for the bucket and it should match with the ones in collection' do
+    authenticate
+    get collection_url(:buckets)
+    (xml_response/'buckets/bucket').each do |r|
+      get collection_url(:buckets) + '/' + r[:id]
+      (xml_response/'bucket/blob').wont_be_empty
+      (xml_response/'bucket/blob').each do |b|
+        b[:id].wont_be_nil
+        b[:href].wont_be_nil
+        b[:href].must_match /^http/
+        b[:href].must_match /#{r[:id]}\/#{b[:id]}$/
+      end
+    end
+  end
+
+  it 'must allow to get all blobs details and the details should be set correctly' do
+    authenticate
+    get collection_url(:buckets)
+    (xml_response/'buckets/bucket').each do |r|
+      get collection_url(:buckets) + '/' + r[:id]
+      (xml_response/'bucket/blob').each do |b|
+        get collection_url(:buckets) + '/' + r[:id] + '/' + b[:id]
+        xml_response.root.name.must_equal 'blob'
+        xml_response.root[:id].must_equal b[:id]
+        (xml_response/'bucket').wont_be_empty
+        (xml_response/'bucket').size.must_equal 1
+        (xml_response/'bucket').first.text.wont_be_nil
+        (xml_response/'bucket').first.text.must_equal r[:id]
+        (xml_response/'content_length').wont_be_empty
+        (xml_response/'content_length').size.must_equal 1
+        (xml_response/'content_length').first.text.must_match /^(\d+)$/
+        (xml_response/'content_type').wont_be_empty
+        (xml_response/'content_type').size.must_equal 1
+        (xml_response/'content_type').first.text.wont_be_empty
+        (xml_response/'last_modified').wont_be_empty
+        (xml_response/'last_modified').size.must_equal 1
+        (xml_response/'last_modified').first.text.wont_be_empty
+        (xml_response/'content').wont_be_empty
+        (xml_response/'content').size.must_equal 1
+        (xml_response/'content').first[:rel].wont_be_nil
+        (xml_response/'content').first[:rel].must_equal 'blob_content'
+        (xml_response/'content').first[:href].wont_be_nil
+        (xml_response/'content').first[:href].must_match /^http/
+        (xml_response/'content').first[:href].must_match /\/content$/
+      end
+    end
+  end
+
+end

data/tests/drivers/mock/common.rb

@@ -0,0 +1,7 @@
+ENV['API_DRIVER']   = 'mock'
+ENV['TESTS_API_USERNAME'] = 'mockuser'
+ENV['TESTS_API_PASSWORD'] = 'mockpassword'
+
+
+$:.unshift File.join(File.dirname(__FILE__), '..', '..', '..')
+require 'tests/minitest_common'

data/tests/drivers/mock/drivers_test.rb

@@ -0,0 +1,123 @@
+$:.unshift File.join(File.dirname(__FILE__), '..', '..', '..')
+require 'tests/drivers/mock/common'
+
+describe 'Deltacloud API drivers' do
+  include Deltacloud::Test
+
+  it 'must advertise have the drivers collection in API entrypoint' do
+    get root_url
+    (xml_response/'api/link[@rel=drivers]').wont_be_empty
+  end
+
+  it 'must not require authentication to access the "driver" collection' do
+    get collection_url(:drivers)
+    last_response.status.must_equal 200
+  end
+
+  it 'should respond with HTTP_OK when accessing the :drivers collection with authentication' do
+    get collection_url(:drivers)
+    last_response.status.must_equal 200
+  end
+
+  it 'should support the JSON media type' do
+    header 'Accept', 'application/json'
+    get collection_url(:drivers)
+    last_response.status.must_equal 200
+    last_response.headers['Content-Type'].must_equal 'application/json'
+  end
+
+  it 'must include the ETag in HTTP headers' do
+    get collection_url(:drivers)
+    last_response.headers['ETag'].wont_be_nil
+  end
+
+  it 'must have the "drivers" element on top level' do
+    get collection_url(:drivers)
+    xml_response.root.name.must_equal 'drivers'
+  end
+
+  it 'must have some "driver" elements inside "drivers"' do
+    get collection_url(:drivers)
+    (xml_response/'drivers/driver').wont_be_empty
+  end
+
+  it 'must provide the :id attribute for each driver in collection' do
+    get collection_url(:drivers)
+    (xml_response/'drivers/driver').each do |r|
+      r[:id].wont_be_nil
+    end
+  end
+
+  it 'must include the :href attribute for each "driver" element in collection' do
+    get collection_url(:drivers)
+    (xml_response/'drivers/driver').each do |r|
+      r[:href].wont_be_nil
+    end
+  end
+
+  it 'must use the absolute URL in each :href attribute' do
+    get collection_url(:drivers)
+    (xml_response/'drivers/driver').each do |r|
+      r[:href].must_match /^http/
+    end
+  end
+
+  it 'must have the URL ending with the :id of the driver' do
+    get collection_url(:drivers)
+    (xml_response/'drivers/driver').each do |r|
+      r[:href].must_match /#{r[:id]}$/
+    end
+  end
+
+  it 'must return the list of valid parameters for the :index action' do
+    options collection_url(:drivers) + '/index'
+    last_response.headers['Allow'].wont_be_nil
+  end
+
+  it 'must have the "name" element defined for each driver in collection' do
+    get collection_url(:drivers)
+    (xml_response/'drivers/driver').each do |r|
+      (r/'name').wont_be_nil
+    end
+  end
+
+
+  it 'must return the full "driver" when following the URL in driver element' do
+    get collection_url(:drivers)
+    (xml_response/'drivers/driver').each do |r|
+      get collection_url(:drivers) + '/' + r[:id]
+      last_response.status.must_equal 200
+    end
+  end
+
+  it 'must have the "name" element for the driver and it should match with the one in collection' do
+    get collection_url(:drivers)
+    (xml_response/'drivers/driver').each do |r|
+      get collection_url(:drivers) + '/' + r[:id]
+      (xml_response/'name').wont_be_empty
+      (xml_response/'name').first.text.must_equal((r/'name').first.text)
+    end
+  end
+
+  it 'should advertise available providers for some drivers' do
+    get collection_url(:drivers)
+    (xml_response/'drivers/driver/provider').each do |p|
+      p[:id].wont_be_nil
+    end
+  end
+
+  it 'should expose entrypoints for each provider if driver has providers defined' do
+    get collection_url(:drivers)
+    (xml_response/'drivers/driver/provider').each do |p|
+      get collection_url(:drivers) + '/' + p.parent[:id]
+      (xml_response/"driver/provider[@id=#{p[:id]}]").wont_be_empty
+      (xml_response/"driver/provider[@id=#{p[:id]}]").size.must_equal 1
+      (xml_response/"driver/provider[@id=#{p[:id]}]/entrypoint").wont_be_empty
+      (xml_response/"driver/provider[@id=#{p[:id]}]/entrypoint").each do |e|
+        e[:kind].wont_be_nil
+        e.text.wont_be_empty
+      end
+    end
+  end
+
+end

data/tests/drivers/mock/hardware_profiles_test.rb

@@ -1,134 +1,224 @@
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements.  See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.  The
-# ASF licenses this file to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance with the
-# License.  You may obtain a copy of the License at
-#
-#       http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
-# License for the specific language governing permissions and limitations
-# under the License.
-#
-
 $:.unshift File.join(File.dirname(__FILE__), '..', '..', '..')
-require 'tests/common'
+require 'tests/drivers/mock/common'
 
-module DeltacloudUnitTest
-  class HardwareProfilesTest < Test::Unit::TestCase
-    include Rack::Test::Methods
+describe 'Deltacloud API Hardware Profiles' do
+  include Deltacloud::Test
 
-    def app
-      Sinatra::Application
-    end
+  it 'must advertise have the hardware_profiles collection in API entrypoint' do
+    get root_url
+    (xml_response/'api/link[@rel=hardware_profiles]').wont_be_empty
+  end
 
-    def test_it_returns_hardware_profiles
-      get_url '/api/hardware_profiles'
-      (last_xml_response/'hardware_profiles/hardware_profile').length.should > 0
-    end
+  it 'should respond with HTTP_OK when accessing the :hardware_profiles collection with authentication' do
+    authenticate
+    get collection_url(:hardware_profiles)
+    last_response.status.must_equal 200
+  end
 
-    def test_it_has_correct_attributes_set
-      get_auth_url '/api/hardware_profiles'
-      (last_xml_response/'hardware_profiles/hardware_profile').each do |profile|
-        profile.attributes.keys.sort.should == [ 'href', 'id' ]
-      end
+  it 'should support the JSON media type' do
+    authenticate
+    header 'Accept', 'application/json'
+    get collection_url(:hardware_profiles)
+    last_response.status.must_equal 200
+    last_response.headers['Content-Type'].must_equal 'application/json'
+  end
+
+  it 'must include the ETag in HTTP headers' do
+    authenticate
+    get collection_url(:hardware_profiles)
+    last_response.headers['ETag'].wont_be_nil
+  end
+
+  it 'must have the "hardware_profiles" element on top level' do
+    authenticate
+    get collection_url(:hardware_profiles)
+    xml_response.root.name.must_equal 'hardware_profiles'
+  end
+
+  it 'must have some "hardware_profile" elements inside "hardware_profiles"' do
+    authenticate
+    get collection_url(:hardware_profiles)
+    (xml_response/'hardware_profiles/hardware_profile').wont_be_empty
+  end
+
+  it 'must provide the :id attribute for each hardware_profile in collection' do
+    authenticate
+    get collection_url(:hardware_profiles)
+    (xml_response/'hardware_profiles/hardware_profile').each do |r|
+      r[:id].wont_be_nil
     end
+  end
 
-    def test_hardware_profiles_have_name
-      get_auth_url '/api/hardware_profiles'
-      (last_xml_response/'hardware_profiles/hardware_profile').each do |profile|
-        (profile/'name').text.should_not == nil
-      end
+  it 'must include the :href attribute for each "hardware_profile" element in collection' do
+    authenticate
+    get collection_url(:hardware_profiles)
+    (xml_response/'hardware_profiles/hardware_profile').each do |r|
+      r[:href].wont_be_nil
     end
+  end
 
-    def test_hardware_profiles_have_unique_name
-      get_auth_url '/api/hardware_profiles'
-      names = []
-      (last_xml_response/'hardware_profiles/hardware_profile').each do |profile|
-        names << (profile/'name').text
-      end
-      names.should == names.uniq
+  it 'must use the absolute URL in each :href attribute' do
+    authenticate
+    get collection_url(:hardware_profiles)
+    (xml_response/'hardware_profiles/hardware_profile').each do |r|
+      r[:href].must_match /^http/
     end
+  end
 
-    def test_hardware_profiles_have_unique_id
-      get_auth_url '/api/hardware_profiles'
-      ids = []
-      (last_xml_response/'hardware_profiles/hardware_profile').each do |profile|
-        ids << profile['id']
-      end
-      ids.should == ids.uniq
+  it 'must have the URL ending with the :id of the hardware_profile' do
+    authenticate
+    get collection_url(:hardware_profiles)
+    (xml_response/'hardware_profiles/hardware_profile').each do |r|
+      r[:href].must_match /#{r[:id]}$/
     end
+  end
 
-    def test_m1_xlarge_profile_has_correct_attributes
-      get_auth_url '/api/hardware_profiles'
-      profile = (last_xml_response/'hardware_profiles/hardware_profile[@id="m1-xlarge"]')
-      test_profile_properties(profile)
+  it 'must return the list of valid parameters for the :index action' do
+    authenticate
+    options collection_url(:hardware_profiles) + '/index'
+    last_response.headers['Allow'].wont_be_nil
+  end
+
+  it 'must have the "name" element defined for each hardware_profile in collection' do
+    authenticate
+    get collection_url(:hardware_profiles)
+    (xml_response/'hardware_profiles/hardware_profile').each do |r|
+      (r/'name').wont_be_empty
     end
+  end
 
-    def test_it_returns_valid_hardware_profile
-      get_auth_url '/api/hardware_profiles/m1-xlarge'
-      profile = (last_xml_response/'hardware_profile')
-      test_profile_properties(profile)
+  it 'should have the "property" element defined if not the opaque hardware_profile' do
+    authenticate
+    get collection_url(:hardware_profiles)
+    (xml_response/'hardware_profiles/hardware_profile').each do |r|
+      next if r[:id] == 'opaque'
+      (r/'property').wont_be_empty
     end
+  end
 
-    def test_it_responses_to_json
-      get_url '/api/hardware_profiles', {}, { :format => :json }
-      JSON::parse(last_response.body).class.should == Hash
-      JSON::parse(last_response.body)['hardware_profiles'].class.should == Array
-      get_url '/api/hardware_profiles/m1-xlarge', {}, { :format => :json }
-      last_response.status.should == 200
-      JSON::parse(last_response.body).class.should == Hash
-      JSON::parse(last_response.body)['hardware_profile'].class.should == Hash
+  it 'must define the :kind attribute for each "property" ' do
+    authenticate
+    get collection_url(:hardware_profiles)
+    (xml_response/'hardware_profiles/hardware_profile').each do |r|
+      next if r[:id] == 'opaque'
+      (r/'property').each { |p| p[:kind].wont_be_nil }
     end
+  end
 
-    def test_it_responses_to_html
-      get_url '/api/hardware_profiles', {}, { :format => :html }
-      last_response.status.should == 200
-      Nokogiri::HTML(last_response.body).search('html').first.name.should == 'html'
-      get_url '/api/hardware_profiles/m1-xlarge', {}, { :format => :html }
-      last_response.status.should == 200
-      Nokogiri::HTML(last_response.body).search('html').first.name.should == 'html'
+  it 'must define the :name attribute for each "property" ' do
+    authenticate
+    get collection_url(:hardware_profiles)
+    (xml_response/'hardware_profiles/hardware_profile').each do |r|
+      next if r[:id] == 'opaque'
+      (r/'property').each { |p| p[:name].wont_be_nil }
     end
+  end
 
-    def test_it_returns_error_on_wrong_name
-      get_url '/api/hardware_profiles/m1-unknown-wrongname', {}, { :format => :html }
-      last_response.status.should == 404
-      get_auth_url '/api/hardware_profiles/m1-unknown-wrongname'
-      last_response.status.should == 404
-      get_url '/api/hardware_profiles/m1-unknown-wrongname', {}, { :format => :json }
-      last_response.status.should == 404
+  it 'must define the :unit attribute for each "property" ' do
+    authenticate
+    get collection_url(:hardware_profiles)
+    (xml_response/'hardware_profiles/hardware_profile').each do |r|
+      next if r[:id] == 'opaque'
+      (r/'property').each { |p| p[:unit].wont_be_nil }
     end
+  end
 
-    private
+  it 'must define the :value attribute for each "property" ' do
+    authenticate
+    get collection_url(:hardware_profiles)
+    (xml_response/'hardware_profiles/hardware_profile').each do |r|
+      next if r[:id] == 'opaque'
+      (r/'property').each { |p| p[:value].wont_be_nil }
+    end
+  end
 
-    def test_profile_properties(profile)
-      (profile/'property').each do |properties|
-        properties.attributes.keys.sort.should == [ 'kind', 'name', 'unit', 'value' ]
+  it 'must define the "param" element if property kind is not "fixed"' do
+    authenticate
+    get collection_url(:hardware_profiles)
+    (xml_response/'hardware_profiles/hardware_profile').each do |r|
+      next if r[:id] == 'opaque'
+      (r/'property').each do |p|
+        next if p[:kind] == 'fixed'
+        (p/'param').wont_be_empty
+        (p/'param').size.must_equal 1
+        (p/'param').first[:href].wont_be_nil
+        (p/'param').first[:href].must_match /^http/
+        (p/'param').first[:method].wont_be_nil
+        (p/'param').first[:name].wont_be_nil
+        (p/'param').first[:operation].wont_be_nil
       end
+    end
+  end
 
-      (profile/'property[@name="architecture"]').first['kind'].should == 'fixed'
-      (profile/'property[@name="architecture"]').first['unit'].should == 'label'
+  it 'must provide the list of valid values when the property is defined as "enum"' do
+    authenticate
+    get collection_url(:hardware_profiles)
+    (xml_response/'hardware_profiles/hardware_profile').each do |r|
+      next if r[:id] == 'opaque'
+      (r/'property').each do |p|
+        next if p[:kind] != 'enum'
+        (p/'enum/entry').wont_be_empty
+        (p/'enum/entry').each { |e| e[:value].wont_be_nil }
+      end
+    end
+  end
 
-      (profile/'property[@name="memory"]').first['kind'].should == 'range'
-      (profile/'property[@name="memory"]').first['unit'].should == 'MB'
-      (profile/'property[@name="memory"]/range').length.should == 1
-      (profile/'property[@name="memory"]/range').first.attributes.keys.sort.should == [ 'first', 'last' ]
+  it 'must provide the range of valid values when the property is defined as "range"' do
+    authenticate
+    get collection_url(:hardware_profiles)
+    (xml_response/'hardware_profiles/hardware_profile').each do |r|
+      next if r[:id] == 'opaque'
+      (r/'property').each do |p|
+        next if p[:kind] != 'range'
+        (p/'range').wont_be_empty
+        (p/'range').size.must_equal 1
+        (p/'range').first[:first].wont_be_nil
+        (p/'range').first[:last].wont_be_nil
+      end
+    end
+  end
 
-      (profile/'property[@name="cpu"]').first['kind'].should == 'fixed'
-      (profile/'property[@name="cpu"]').first['unit'].should == 'count'
+  it 'must provide the default value within the range if property defined as "range"' do
+    authenticate
+    get collection_url(:hardware_profiles)
+    (xml_response/'hardware_profiles/hardware_profile').each do |r|
+      next if r[:id] == 'opaque'
+      (r/'property').each do |p|
+        next if p[:kind] != 'range'
+        ((p/'range').first[:first].to_i..(p/'range').first[:last].to_i).include?(p[:value].to_i).must_equal true
+      end
+    end
+  end
 
-      (profile/'property[@name="storage"]').first['kind'].should == 'enum'
-      (profile/'property[@name="storage"]').first['unit'].should == 'GB'
-      (profile/'property[@name="storage"]/enum').length.should == 1
-      (profile/'property[@name="storage"]/enum/entry').length.should == 3
-      (profile/'property[@name="storage"]/enum/entry').each do |entry|
-        entry.attributes.keys.should == [ 'value' ]
-        entry['value'].should_not == nil
+  it 'must provide the default value that is included in enum list if property defined as "enum"' do
+    authenticate
+    get collection_url(:hardware_profiles)
+    (xml_response/'hardware_profiles/hardware_profile').each do |r|
+      next if r[:id] == 'opaque'
+      (r/'property').each do |p|
+        next if p[:kind] != 'enum'
+        (p/'enum/entry').map { |e| e[:value] }.include?(p[:value]).must_equal true
       end
     end
+  end
 
+  it 'must return the full "hardware_profile" when following the URL in hardware_profile element' do
+    authenticate
+    get collection_url(:hardware_profiles)
+    (xml_response/'hardware_profiles/hardware_profile').each do |r|
+      get collection_url(:hardware_profiles) + '/' + r[:id]
+      last_response.status.must_equal 200
+    end
   end
+
+  it 'must have the "name" element for the hardware_profile and it should match with the one in collection' do
+    authenticate
+    get collection_url(:hardware_profiles)
+    (xml_response/'hardware_profiles/hardware_profile').each do |r|
+      get collection_url(:hardware_profiles) + '/' + r[:id]
+      (xml_response/'name').wont_be_empty
+      (xml_response/'name').first.text.must_equal((r/'name').first.text)
+    end
+  end
+
 end