chef 12.18.31 → 13.0.118

data/spec/unit/data_collector/messages_spec.rb

@@ -116,6 +116,141 @@ describe Chef::DataCollector::Messages do
           deprecations
         }
       end
+      let(:optional_fields) { %w{error policy_group policy_name} }
+
+      before do
+        allow(run_status).to receive(:exception).and_return(nil)
+      end
+
+      it "is not missing any required fields" do
+        missing_fields = required_fields.select do |key|
+          !Chef::DataCollector::Messages.run_end_message(reporter_data).key?(key)
+        end
+        expect(missing_fields).to eq([])
+      end
+
+      it "does not have any extra fields" do
+        extra_fields = Chef::DataCollector::Messages.run_end_message(reporter_data).keys.select do |key|
+          !required_fields.include?(key) && !optional_fields.include?(key)
+        end
+        expect(extra_fields).to eq([])
+      end
+
+      it "only includes updated resources in its count" do
+        message = Chef::DataCollector::Messages.run_end_message(reporter_data)
+        expect(message["total_resource_count"]).to eq(2)
+        expect(message["updated_resource_count"]).to eq(1)
+      end
+    end
+
+    context "when the run was not successful" do
+      let(:required_fields) do
+        %w{
+          chef_server_fqdn
+          entity_uuid
+          id
+          end_time
+          error
+          expanded_run_list
+          message_type
+          message_version
+          node
+          node_name
+          organization_name
+          resources
+          run_id
+          run_list
+          source
+          start_time
+          status
+          total_resource_count
+          updated_resource_count
+          deprecations
+        }
+      end
+      let(:optional_fields) { %w{policy_group policy_name} }
+
+      before do
+        allow(run_status).to receive(:exception).and_return(RuntimeError.new("an error happened"))
+      end
+
+      it "is not missing any required fields" do
+        missing_fields = required_fields.select do |key|
+          !Chef::DataCollector::Messages.run_end_message(reporter_data).key?(key)
+        end
+        expect(missing_fields).to eq([])
+      end
+
+      it "does not have any extra fields" do
+        extra_fields = Chef::DataCollector::Messages.run_end_message(reporter_data).keys.select do |key|
+          !required_fields.include?(key) && !optional_fields.include?(key)
+        end
+        expect(extra_fields).to eq([])
+      end
+    end
+  end
+
+  describe "#run_end_message in policy mode" do
+    let(:node) { Chef::Node.new }
+    let(:run_status) { Chef::RunStatus.new(node, Chef::EventDispatch::Dispatcher.new) }
+    let(:report1)  { double("report1", report_data: { "status" => "updated" }) }
+    let(:report2)  { double("report2", report_data: { "status" => "skipped" }) }
+    let(:reporter_data) do
+      {
+        run_status: run_status,
+        resources: [report1, report2],
+      }
+    end
+
+    before do
+      allow(run_status).to receive(:start_time).and_return(Time.now)
+      allow(run_status).to receive(:end_time).and_return(Time.now)
+      node.policy_group = "test"
+      node.policy_name = "policy-test"
+    end
+
+    it "includes a valid node object in the payload" do
+      message = Chef::DataCollector::Messages.run_end_message(reporter_data)
+      expect(message["node"]).to be_an_instance_of(Chef::Node)
+    end
+
+    it "returns a sane JSON representation of the node object" do
+      node.chef_environment = "my_test_environment"
+      node.run_list.add("recipe[my_test_cookbook::default]")
+      message = FFI_Yajl::Parser.parse(Chef::DataCollector::Messages.run_end_message(reporter_data).to_json)
+
+      expect(message["node"]["chef_environment"]).to eq("my_test_environment")
+      expect(message["node"]["run_list"]).to eq(["recipe[my_test_cookbook::default]"])
+      expect(message["node"]["policy_name"]).to eq("policy-test")
+      expect(message["node"]["policy_group"]).to eq("test")
+    end
+
+    context "when the run was successful" do
+      let(:required_fields) do
+        %w{
+          chef_server_fqdn
+          entity_uuid
+          id
+          end_time
+          expanded_run_list
+          message_type
+          message_version
+          node
+          node_name
+          organization_name
+          resources
+          run_id
+          run_list
+          source
+          start_time
+          status
+          total_resource_count
+          updated_resource_count
+          deprecations
+          policy_name
+          policy_group
+        }
+      end
       let(:optional_fields) { %w{error} }
 
       before do
@@ -166,6 +301,8 @@ describe Chef::DataCollector::Messages do
           total_resource_count
           updated_resource_count
           deprecations
+          policy_name
+          policy_group
         }
       end
       let(:optional_fields) { [] }

data/spec/unit/data_collector/resource_report_spec.rb

@@ -0,0 +1,145 @@
+#
+# Author:: Salim Afiune (<afiune@chef.io)
+#
+# Copyright:: Copyright 2012-2017, Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed 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.
+#
+
+require "spec_helper"
+
+describe Chef::DataCollector::ResourceReport do
+  let(:cookbook_repo_path) { File.join(CHEF_SPEC_DATA, "cookbooks") }
+  let(:cookbook_collection) { Chef::CookbookCollection.new(Chef::CookbookLoader.new(cookbook_repo_path)) }
+  let(:node) { Chef::Node.new }
+  let(:events) { Chef::EventDispatch::Dispatcher.new }
+  let(:run_context) { Chef::RunContext.new(node, cookbook_collection, events) }
+  let(:resource) { Chef::Resource.new("zelda", run_context) }
+  let(:report) { described_class.new(resource, :create) }
+
+  describe "#skipped" do
+    let(:conditional) { double("Chef::Resource::Conditional") }
+
+    it "should set status and conditional" do
+      report.skipped(conditional)
+      expect(report.conditional).to eq conditional
+      expect(report.status).to eq "skipped"
+    end
+  end
+
+  describe "#up_to_date" do
+    it "should set status" do
+      report.up_to_date
+      expect(report.status).to eq "up-to-date"
+    end
+  end
+
+  describe "#updated" do
+    it "should set status" do
+      report.updated
+      expect(report.status).to eq "updated"
+    end
+  end
+
+  describe "#elapsed_time_in_milliseconds" do
+
+    context "when elapsed_time is not set" do
+      it "should return nil" do
+        allow(report).to receive(:elapsed_time).and_return(nil)
+        expect(report.elapsed_time_in_milliseconds).to eq nil
+      end
+    end
+
+    context "when elapsed_time is set" do
+      it "should return it in milliseconds" do
+        allow(report).to receive(:elapsed_time).and_return(1)
+        expect(report.elapsed_time_in_milliseconds).to eq 1000
+      end
+    end
+  end
+
+  describe "#failed" do
+    let(:exception) { double("Chef::Exception::Test") }
+
+    it "should set exception and status" do
+      report.failed(exception)
+      expect(report.exception).to eq exception
+      expect(report.status).to eq "failed"
+    end
+  end
+
+  describe "#to_hash" do
+    context "for a simple_resource" do
+      let(:resource) do
+        klass = Class.new(Chef::Resource) do
+          resource_name "zelda"
+        end
+        klass.new("hyrule", run_context)
+      end
+      let(:hash) do
+        {
+          "after" => {},
+          "before" => {},
+          "delta" => "",
+          "duration" => "",
+          "id" => "hyrule",
+          "ignore_failure" => false,
+          "name" => "hyrule",
+          "result" => "create",
+          "status" => "unprocessed",
+          "type" => :zelda,
+        }
+      end
+
+      it "returns a hash containing the expected values" do
+        expect(report.to_hash).to eq hash
+      end
+    end
+
+    context "for a lazy_resource that got skipped" do
+      let(:resource) do
+        klass = Class.new(Chef::Resource) do
+          resource_name "link"
+          property :sword, String, name_property: true, identity: true
+        end
+        resource = klass.new("hyrule")
+        resource.sword = Chef::DelayedEvaluator.new { nil }
+        resource
+      end
+      let(:hash) do
+        {
+          "after" => {},
+          "before" => {},
+          "delta" => "",
+          "duration" => "",
+          "conditional" => "because",
+          "id" => "unknown identity (due to Chef::Exceptions::ValidationFailed)",
+          "ignore_failure" => false,
+          "name" => "hyrule",
+          "result" => "create",
+          "status" => "skipped",
+          "type" => :link,
+        }
+      end
+      let(:conditional) do
+        double("Chef::Resource::Conditional", :to_text => "because")
+      end
+
+      it "should handle any Exception and throw a helpful message by mocking the identity" do
+        report.skipped(conditional)
+        expect(report.to_hash).to eq hash
+      end
+    end
+  end
+end

data/spec/unit/deprecation_spec.rb

@@ -45,20 +45,6 @@ describe Chef::Deprecation do
     add_deprecation_warnings_for(DeprecatedMethods.instance_methods)
   end
 
-  method_snapshot_file = File.join(CHEF_SPEC_DATA, "file-providers-method-snapshot-chef-11-4.json")
-  method_snapshot = Chef::JSONCompat.parse(File.open(method_snapshot_file).read())
-
-  method_snapshot.each do |class_name, old_methods|
-    class_object = class_from_string(class_name)
-    current_methods = class_object.public_instance_methods.map(&:to_sym)
-
-    it "defines all methods on #{class_object} that were available in 11.0" do
-      old_methods.each do |old_method|
-        expect(current_methods).to include(old_method.to_sym)
-      end
-    end
-  end
-
   context "when Chef::Config[:treat_deprecation_warnings_as_errors] is off" do
     before do
       Chef::Config[:treat_deprecation_warnings_as_errors] = false

data/spec/unit/encrypted_data_bag_item_spec.rb

@@ -39,7 +39,7 @@ describe Chef::EncryptedDataBagItem::Encryptor do
   let(:key) { "passwd" }
 
   it "encrypts to format version 1 by default" do
-    expect(encryptor).to be_a_instance_of(Chef::EncryptedDataBagItem::Encryptor::Version1Encryptor)
+    expect(encryptor).to be_a_instance_of(Chef::EncryptedDataBagItem::Encryptor::Version3Encryptor)
   end
 
   describe "generating a random IV" do
@@ -66,8 +66,8 @@ describe Chef::EncryptedDataBagItem::Encryptor do
       final_data = encryptor.for_encrypted_item
       expect(final_data["encrypted_data"]).to eq encryptor.encrypted_data
       expect(final_data["iv"]).to eq Base64.encode64(encryptor.iv)
-      expect(final_data["version"]).to eq 1
-      expect(final_data["cipher"]).to eq "aes-256-cbc"
+      expect(final_data["version"]).to eq 3
+      expect(final_data["cipher"]).to eq "aes-256-gcm"
     end
   end
 
@@ -238,7 +238,7 @@ describe Chef::EncryptedDataBagItem::Decryptor do
   context "when decrypting a version 1 (JSON+aes-256-cbc+random iv) encrypted value" do
 
     let(:encrypted_value) do
-      Chef::EncryptedDataBagItem::Encryptor.new(plaintext_data, encryption_key).for_encrypted_item
+      Chef::EncryptedDataBagItem::Encryptor::Version1Encryptor.new(plaintext_data, encryption_key).for_encrypted_item
     end
 
     it "selects the correct strategy for version 1" do
@@ -336,7 +336,7 @@ describe Chef::EncryptedDataBagItem do
     end
 
     it "encrypts non-collection objects" do
-      expect(encoded_data["greeting"]["version"]).to eq 1
+      expect(encoded_data["greeting"]["version"]).to eq 3
       expect(encoded_data["greeting"]).to have_key("iv")
 
       iv = encoded_data["greeting"]["iv"]
@@ -346,7 +346,7 @@ describe Chef::EncryptedDataBagItem do
     end
 
     it "encrypts nested values" do
-      expect(encoded_data["nested"]["version"]).to eq 1
+      expect(encoded_data["nested"]["version"]).to eq 3
       expect(encoded_data["nested"]).to have_key("iv")
 
       iv = encoded_data["nested"]["iv"]

data/spec/unit/formatters/error_description_spec.rb

@@ -49,7 +49,21 @@ describe Chef::Formatters::ErrorDescription do
 
   describe "#display" do
     before do
-      stub_const("RUBY_PLATFORM", "ruby-foo-9000")
+      stub_const("Chef::VERSION", "1.2.3")
+      stub_const("RUBY_DESCRIPTION", "ruby 2.3.1p112 (2016-04-26 revision 54768) [x86_64-darwin15]")
+      allow(subject).to receive(:caller) { Kernel.caller + ["/test/bin/chef-client:1:in `<main>'"] }
+      allow(File).to receive(:realpath).and_call_original
+      allow(File).to receive(:realpath).with("/test/bin/chef-client").and_return("/test/bin/chef-client")
+    end
+
+    around do |ex|
+      old_program_name = $PROGRAM_NAME
+      begin
+        $PROGRAM_NAME = "chef-client"
+        ex.run
+      ensure
+        $PROGRAM_NAME = old_program_name
+      end
     end
 
     context "when no sections have been added" do
@@ -60,9 +74,12 @@ describe Chef::Formatters::ErrorDescription do
 test title
 ================================================================================
 
-Platform:
----------
-ruby-foo-9000
+System Info:
+------------
+chef_version=1.2.3
+ruby=ruby 2.3.1p112 (2016-04-26 revision 54768) [x86_64-darwin15]
+program_name=chef-client
+executable=/test/bin/chef-client
 
         END
       end
@@ -84,9 +101,37 @@ test heading
 ------------
 test text
 
-Platform:
----------
-ruby-foo-9000
+System Info:
+------------
+chef_version=1.2.3
+ruby=ruby 2.3.1p112 (2016-04-26 revision 54768) [x86_64-darwin15]
+program_name=chef-client
+executable=/test/bin/chef-client
+
+        END
+      end
+
+    end
+
+    context "when node object is available" do
+      it "should output the expected sections" do
+        # This can't be in a before block because the spec-wide helper calls a
+        # reset on global values.
+        Chef.set_node({ "platform" => "openvms", "platform_version" => "8.4-2L1" })
+        subject.display(out)
+        expect(out.out.string).to eq <<-END
+================================================================================
+test title
+================================================================================
+
+System Info:
+------------
+chef_version=1.2.3
+platform=openvms
+platform_version=8.4-2L1
+ruby=ruby 2.3.1p112 (2016-04-26 revision 54768) [x86_64-darwin15]
+program_name=chef-client
+executable=/test/bin/chef-client
 
         END
       end

data/spec/unit/http/api_versions_spec.rb

@@ -0,0 +1,79 @@
+#
+# Copyright:: Copyright 2017, Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed 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.
+#
+
+require "spec_helper"
+
+describe Chef::HTTP::APIVersions do
+  class TestVersionClient < Chef::HTTP
+    use Chef::HTTP::APIVersions
+  end
+
+  before do
+    Chef::ServerAPIVersions.instance.reset!
+  end
+
+  let(:method) { "GET" }
+  let(:url) { "http://dummy.com" }
+  let(:headers) { {} }
+  let(:data) { false }
+
+  let(:request) {}
+  let(:return_value) { "200" }
+
+  # Test Variables
+  let(:response_body) { "Thanks for checking in." }
+  let(:response_headers) do
+    {
+      "x-ops-server-api-version" => { "min_version" => 0, "max_version" => 2 }.to_json,
+    }
+  end
+
+  let(:response) do
+    m = double("HttpResponse", :body => response_body)
+    allow(m).to receive(:key?).with("x-ops-server-api-version").and_return(true)
+    allow(m).to receive(:code).and_return(return_value)
+    allow(m).to receive(:[]) do |key|
+      response_headers[key]
+    end
+
+    m
+  end
+
+  let(:middleware) do
+    client = TestVersionClient.new(url)
+    client.middlewares[0]
+  end
+
+  def run_api_version_handler
+    middleware.handle_request(method, url, headers, data)
+    middleware.handle_response(response, request, return_value)
+  end
+
+  it "correctly stores server api versions" do
+    run_api_version_handler
+    expect(Chef::ServerAPIVersions.instance.min_server_version).to eq(0)
+  end
+
+  context "with an unacceptable api version" do
+    let (:return_value) { "406" }
+    it "resets the list of supported versions" do
+      Chef::ServerAPIVersions.instance.set_versions({ "min_version" => 1, "max_version" => 3 })
+      run_api_version_handler
+      expect(Chef::ServerAPIVersions.instance.min_server_version).to eq(0)
+    end
+  end
+end

data/spec/unit/http/authenticator_spec.rb

@@ -38,6 +38,26 @@ describe Chef::HTTP::Authenticator do
           to include({ "X-Ops-Server-API-Version" => Chef::HTTP::Authenticator::DEFAULT_SERVER_API_VERSION })
       end
 
+      context "when version_class is provided" do
+        class V0Class; extend Chef::Mixin::VersionedAPI; minimum_api_version 0; end
+        class V2Class; extend Chef::Mixin::VersionedAPI; minimum_api_version 2; end
+
+        class AuthFactoryClass
+          extend Chef::Mixin::VersionedAPIFactory
+          add_versioned_api_class V0Class
+          add_versioned_api_class V2Class
+        end
+
+        let(:class_instance) { Chef::HTTP::Authenticator.new({ version_class: AuthFactoryClass }) }
+
+        it "uses it to select the correct http version" do
+          Chef::ServerAPIVersions.instance.reset!
+          expect(AuthFactoryClass).to receive(:best_request_version).and_call_original
+          expect(class_instance.handle_request(method, url, headers, data)[2]).
+            to include({ "X-Ops-Server-API-Version" => "2" })
+        end
+      end
+
       context "when api_version is set to something other than the default" do
         let(:class_instance) { Chef::HTTP::Authenticator.new({ :api_version => "-10" }) }
 

data/spec/unit/http/socketless_chef_zero_client_spec.rb

@@ -132,7 +132,7 @@ describe Chef::HTTP::SocketlessChefZeroClient do
 
     let(:method) { :GET }
     let(:relative_url) { "clients" }
-    let(:headers) { { "Accept" => "application/json" } }
+    let(:headers) { { "Accept" => "application/json", "X-Ops-Server-API-Version" => "2" } }
     let(:body) { false }
 
     let(:expected_rack_req) do
@@ -144,6 +144,7 @@ describe Chef::HTTP::SocketlessChefZeroClient do
         "QUERY_STRING"    => uri.query,
         "SERVER_PORT"     => uri.port,
         "HTTP_HOST"       => "localhost:#{uri.port}",
+        "HTTP_X_OPS_SERVER_API_VERSION" => "2",
         "rack.url_scheme" => "chefzero",
         "rack.input"      => an_instance_of(StringIO),
       }

data/spec/unit/json_compat_spec.rb

@@ -22,28 +22,6 @@ require "chef/json_compat"
 describe Chef::JSONCompat do
   before { Chef::Config[:treat_deprecation_warnings_as_errors] = false }
 
-  describe "#from_json with JSON containing an existing class" do
-    let(:json) { '{"json_class": "Chef::Role"}' }
-
-    it "emits a deprecation warning" do
-      Chef::Config[:treat_deprecation_warnings_as_errors] = true
-      expect { Chef::JSONCompat.from_json(json) }.to raise_error Chef::Exceptions::DeprecatedFeatureError,
-        /Auto inflation of JSON data is deprecated. Please use Chef::Role#from_hash/
-    end
-
-    it "returns an instance of the class instead of a Hash" do
-      expect(Chef::JSONCompat.from_json(json).class).to eq Chef::Role
-    end
-  end
-
-  describe "#from_json with JSON containing comments" do
-    let(:json) { %Q{{\n/* comment */\n// comment 2\n"json_class": "Chef::Role"}} }
-
-    it "returns an instance of the class instead of a Hash" do
-      expect(Chef::JSONCompat.from_json(json).class).to eq Chef::Role
-    end
-  end
-
   describe "#parse with JSON containing comments" do
     let(:json) { %Q{{\n/* comment */\n// comment 2\n"json_class": "Chef::Role"}} }
 
@@ -52,16 +30,6 @@ describe Chef::JSONCompat do
     end
   end
 
-  describe 'with JSON containing "Chef::Sandbox" as a json_class value' do
-    require "chef/sandbox" # Only needed for this test
-
-    let(:json) { '{"json_class": "Chef::Sandbox", "arbitrary": "data"}' }
-
-    it "returns a Hash, because Chef::Sandbox is a dummy class" do
-      expect(Chef::JSONCompat.from_json(json)).to eq({ "json_class" => "Chef::Sandbox", "arbitrary" => "data" })
-    end
-  end
-
   describe "when pretty printing an object that defines #to_json" do
     class Foo
       def to_json(*a)

data/spec/unit/knife/bootstrap_spec.rb

@@ -48,6 +48,35 @@ describe Chef::Knife::Bootstrap do
     expect(File.basename(knife.bootstrap_template)).to eq("chef-full")
   end
 
+  context "when using the chef-full default template" do
+    let(:rendered_template) do
+      knife.merge_configs
+      knife.render_template
+    end
+
+    it "should render client.rb" do
+      expect(rendered_template).to match("cat > /etc/chef/client.rb <<'EOP'")
+      expect(rendered_template).to match("chef_server_url  \"https://localhost:443\"")
+      expect(rendered_template).to match("validation_client_name \"chef-validator\"")
+      expect(rendered_template).to match("log_location   STDOUT")
+    end
+
+    it "should render first-boot.json" do
+      expect(rendered_template).to match("cat > /etc/chef/first-boot.json <<'EOP'")
+      expect(rendered_template).to match('{"run_list":\[\]}')
+    end
+
+    context "and encrypted_data_bag_secret was provided" do
+      it "should render encrypted_data_bag_secret file" do
+        expect(knife).to receive(:encryption_secret_provided_ignore_encrypt_flag?).and_return(true)
+        expect(knife).to receive(:read_secret).and_return("secrets")
+        expect(rendered_template).to match("cat > /etc/chef/encrypted_data_bag_secret <<'EOP'")
+        expect(rendered_template).to match('{"run_list":\[\]}')
+        expect(rendered_template).to match(%r{secrets})
+      end
+    end
+  end
+
   context "with --bootstrap-vault-item" do
     let(:bootstrap_cli_options) { [ "--bootstrap-vault-item", "vault1:item1", "--bootstrap-vault-item", "vault1:item2", "--bootstrap-vault-item", "vault2:item1" ] }
     it "sets the knife config cli option correctly" do
@@ -649,6 +678,7 @@ describe Chef::Knife::Bootstrap do
         Chef::Config[:knife][:forward_agent] = true
         Chef::Config[:knife][:ssh_identity_file] = "~/.ssh/you.rsa"
         Chef::Config[:knife][:ssh_gateway] = "towel.blinkenlights.nl"
+        Chef::Config[:knife][:ssh_gateway_identity] = "~/.ssh/gateway.rsa"
         Chef::Config[:knife][:host_key_verify] = true
         allow(knife).to receive(:render_template).and_return("")
         knife.config = {}
@@ -676,6 +706,10 @@ describe Chef::Knife::Bootstrap do
         expect(knife_ssh.config[:ssh_gateway]).to eq("towel.blinkenlights.nl")
       end
 
+      it "configures the ssh gateway identity" do
+        expect(knife_ssh.config[:ssh_gateway_identity]).to eq("~/.ssh/gateway.rsa")
+      end
+
       it "configures the host key verify mode" do
         expect(knife_ssh.config[:host_key_verify]).to eq(true)
       end

data/spec/unit/knife/configure_client_spec.rb

@@ -58,8 +58,6 @@ describe Chef::Knife::ConfigureClient do
       it "should write out the config file" do
         allow(FileUtils).to receive(:mkdir_p)
         @knife.run
-        expect(@client_file.string).to match /log_level\s+\:info/
-        expect(@client_file.string).to match /log_location\s+STDOUT/
         expect(@client_file.string).to match /chef_server_url\s+'https\:\/\/chef\.example\.com'/
         expect(@client_file.string).to match /validation_client_name\s+'chef-validator'/
       end