puppet 7.28.0-x86-mingw32 → 7.29.0-x86-mingw32

data/spec/integration/util/windows/user_spec.rb

@@ -1,226 +0,0 @@
-require 'spec_helper'
-
-describe "Puppet::Util::Windows::User", :if => Puppet::Util::Platform.windows? do
-  describe "2003 without UAC" do
-    before :each do
-      allow(Puppet::Util::Windows::Process).to receive(:windows_major_version).and_return(5)
-      allow(Puppet::Util::Windows::Process).to receive(:supports_elevated_security?).and_return(false)
-    end
-
-    it "should be an admin if user's token contains the Administrators SID" do
-      expect(Puppet::Util::Windows::User).to receive(:check_token_membership).and_return(true)
-
-      expect(Puppet::Util::Windows::User).to be_admin
-    end
-
-    it "should not be an admin if user's token doesn't contain the Administrators SID" do
-      expect(Puppet::Util::Windows::User).to receive(:check_token_membership).and_return(false)
-
-      expect(Puppet::Util::Windows::User).not_to be_admin
-    end
-
-    it "should raise an exception if we can't check token membership" do
-      expect(Puppet::Util::Windows::User).to receive(:check_token_membership).and_raise(Puppet::Util::Windows::Error, "Access denied.")
-
-      expect { Puppet::Util::Windows::User.admin? }.to raise_error(Puppet::Util::Windows::Error, /Access denied./)
-    end
-  end
-
-  context "2008 with UAC" do
-    before :each do
-      allow(Puppet::Util::Windows::Process).to receive(:windows_major_version).and_return(6)
-      allow(Puppet::Util::Windows::Process).to receive(:supports_elevated_security?).and_return(true)
-    end
-
-    describe "in local administrators group" do
-      before :each do
-        allow(Puppet::Util::Windows::User).to receive(:check_token_membership).and_return(true)
-      end
-
-      it "should be an admin if user is running with elevated privileges" do
-        allow(Puppet::Util::Windows::Process).to receive(:elevated_security?).and_return(true)
-
-        expect(Puppet::Util::Windows::User).to be_admin
-      end
-
-      it "should not be an admin if user is not running with elevated privileges" do
-        allow(Puppet::Util::Windows::Process).to receive(:elevated_security?).and_return(false)
-
-        expect(Puppet::Util::Windows::User).not_to be_admin
-      end
-
-      it "should raise an exception if the process fails to open the process token" do
-        allow(Puppet::Util::Windows::Process).to receive(:elevated_security?).and_raise(Puppet::Util::Windows::Error, "Access denied.")
-
-        expect { Puppet::Util::Windows::User.admin? }.to raise_error(Puppet::Util::Windows::Error, /Access denied./)
-      end
-    end
-
-    describe "not in local administrators group" do
-      before :each do
-        allow(Puppet::Util::Windows::User).to receive(:check_token_membership).and_return(false)
-      end
-
-      it "should not be an admin if user is running with elevated privileges" do
-        allow(Puppet::Util::Windows::Process).to receive(:elevated_security?).and_return(true)
-
-        expect(Puppet::Util::Windows::User).not_to be_admin
-      end
-
-      it "should not be an admin if user is not running with elevated privileges" do
-        allow(Puppet::Util::Windows::Process).to receive(:elevated_security?).and_return(false)
-
-        expect(Puppet::Util::Windows::User).not_to be_admin
-      end
-    end
-  end
-
-  describe "module function" do
-    let(:username) { 'fabio' }
-    let(:bad_password) { 'goldilocks' }
-    let(:logon_fail_msg) { /Failed to logon user "fabio":  Logon failure: unknown user name or bad password./ }
-
-    def expect_logon_failure_error(&block)
-      expect {
-        yield
-      }.to raise_error { |error|
-        expect(error).to be_a(Puppet::Util::Windows::Error)
-        # https://msdn.microsoft.com/en-us/library/windows/desktop/ms681385(v=vs.85).aspx
-        # ERROR_LOGON_FAILURE 1326
-        expect(error.code).to eq(1326)
-      }
-    end
-
-    describe "load_profile" do
-      it "should raise an error when provided with an incorrect username and password" do
-        expect_logon_failure_error {
-          Puppet::Util::Windows::User.load_profile(username, bad_password)
-        }
-      end
-
-      it "should raise an error when provided with an incorrect username and nil password" do
-        expect_logon_failure_error {
-          Puppet::Util::Windows::User.load_profile(username, nil)
-        }
-      end
-    end
-
-    describe "logon_user" do
-      let(:fLOGON32_PROVIDER_DEFAULT) {0}
-      let(:fLOGON32_LOGON_INTERACTIVE) {2}
-      let(:fLOGON32_LOGON_NETWORK) {3}
-      let(:token) {'test'}
-      let(:user) {'test'}
-      let(:passwd) {'test'}
-      it "should raise an error when provided with an incorrect username and password" do
-        expect_logon_failure_error {
-          Puppet::Util::Windows::User.logon_user(username, bad_password)
-        }
-      end
-
-      it "should raise an error when provided with an incorrect username and nil password" do
-        expect_logon_failure_error {
-          Puppet::Util::Windows::User.logon_user(username, nil)
-        }
-      end
-
-      it 'should raise error given that logon returns false' do
-        allow(Puppet::Util::Windows::User).to receive(:logon_user_by_logon_type).with(
-            user, '.', passwd, fLOGON32_LOGON_NETWORK, fLOGON32_PROVIDER_DEFAULT, anything).and_return (0)
-        allow(Puppet::Util::Windows::User).to receive(:logon_user_by_logon_type).with(
-            user, '.', passwd, fLOGON32_LOGON_INTERACTIVE, fLOGON32_PROVIDER_DEFAULT, anything).and_return(0)
-
-        expect {Puppet::Util::Windows::User.logon_user(user, passwd) {}}
-            .to raise_error(Puppet::Util::Windows::Error, /Failed to logon user/)
-      end
-    end
-
-    describe "password_is?" do
-      it "should return false given an incorrect username and password" do
-        expect(Puppet::Util::Windows::User.password_is?(username, bad_password)).to be_falsey
-      end
-
-      it "should return false given a nil username and an incorrect password" do
-        expect(Puppet::Util::Windows::User.password_is?(nil, bad_password)).to be_falsey
-      end
-
-      context "with a correct password" do
-        it "should return true even if account restrictions are in place " do
-          error = Puppet::Util::Windows::Error.new('', Puppet::Util::Windows::User::ERROR_ACCOUNT_RESTRICTION)
-          allow(Puppet::Util::Windows::User).to receive(:logon_user).and_raise(error)
-          expect(Puppet::Util::Windows::User.password_is?(username, 'p@ssword')).to be(true)
-        end
-
-        it "should return true even for an account outside of logon hours" do
-          error = Puppet::Util::Windows::Error.new('', Puppet::Util::Windows::User::ERROR_INVALID_LOGON_HOURS)
-          allow(Puppet::Util::Windows::User).to receive(:logon_user).and_raise(error)
-          expect(Puppet::Util::Windows::User.password_is?(username, 'p@ssword')).to be(true)
-        end
-
-        it "should return true even for an account not allowed to log into this workstation" do
-          error = Puppet::Util::Windows::Error.new('', Puppet::Util::Windows::User::ERROR_INVALID_WORKSTATION)
-          allow(Puppet::Util::Windows::User).to receive(:logon_user).and_raise(error)
-          expect(Puppet::Util::Windows::User.password_is?(username, 'p@ssword')).to be(true)
-        end
-
-        it "should return true even for a disabled account" do
-          error = Puppet::Util::Windows::Error.new('', Puppet::Util::Windows::User::ERROR_ACCOUNT_DISABLED)
-          allow(Puppet::Util::Windows::User).to receive(:logon_user).and_raise(error)
-          expect(Puppet::Util::Windows::User.password_is?(username, 'p@ssword')).to be(true)
-        end
-      end
-    end
-
-    describe "check_token_membership" do
-      it "should not raise an error" do
-        # added just to call an FFI code path on all platforms
-        expect { Puppet::Util::Windows::User.check_token_membership }.not_to raise_error
-      end
-    end
-
-    describe "default_system_account?" do
-      it "should succesfully identify 'SYSTEM' user as a default system account" do
-        allow(Puppet::Util::Windows::SID).to receive(:name_to_sid).with('SYSTEM').and_return(Puppet::Util::Windows::SID::LocalSystem)
-        expect(Puppet::Util::Windows::User.default_system_account?('SYSTEM')).to eq(true)
-      end
-
-      it "should succesfully identify 'NETWORK SERVICE' user as a default system account" do
-        allow(Puppet::Util::Windows::SID).to receive(:name_to_sid).with('NETWORK SERVICE').and_return(Puppet::Util::Windows::SID::NtNetwork)
-        expect(Puppet::Util::Windows::User.default_system_account?('NETWORK SERVICE')).to eq(true)
-      end
-
-      it "should succesfully identify 'LOCAL SERVICE' user as a default system account" do
-        allow(Puppet::Util::Windows::SID).to receive(:name_to_sid).with('LOCAL SERVICE').and_return(Puppet::Util::Windows::SID::NtLocal)
-        expect(Puppet::Util::Windows::User.default_system_account?('LOCAL SERVICE')).to eq(true)
-      end
-
-      it "should not identify user with unknown sid as a default system account" do
-        allow(Puppet::Util::Windows::SID).to receive(:name_to_sid).with('UnknownUser').and_return(Puppet::Util::Windows::SID::Null)
-        expect(Puppet::Util::Windows::User.default_system_account?('UnknownUser')).to eq(false)
-      end
-    end
-
-    describe "localsystem?" do
-      before do
-        allow(Puppet::Util::Windows::ADSI).to receive(:computer_name).and_return("myPC")
-      end
-
-      ['LocalSystem', '.\LocalSystem', 'myPC\LocalSystem', 'lOcALsysTem'].each do |input|
-        it "should succesfully identify #{input} as the 'LocalSystem' account" do
-          expect(Puppet::Util::Windows::User.localsystem?(input)).to eq(true)
-        end
-      end
-
-      it "should not identify any other user as the 'LocalSystem' account" do
-        expect(Puppet::Util::Windows::User.localsystem?('OtherUser')).to eq(false)
-      end
-    end
-
-    describe "get_rights" do
-      it "should be empty when given user does not exist" do
-        allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('NonExistingUser').and_return(nil)
-        expect(Puppet::Util::Windows::User.get_rights('NonExistingUser')).to eq("")
-      end
-    end
-  end
-end

data/spec/integration/util_spec.rb

@@ -1,104 +0,0 @@
-# coding: utf-8
-require 'spec_helper'
-
-describe Puppet::Util do
-  include PuppetSpec::Files
-
-  describe "#replace_file on Windows", :if => Puppet::Util::Platform.windows? do
-    it "replace_file should preserve original ACEs from existing replaced file on Windows" do
-
-      file = tmpfile("somefile")
-      FileUtils.touch(file)
-
-      admins = 'S-1-5-32-544'
-      dacl = Puppet::Util::Windows::AccessControlList.new
-      dacl.allow(admins, Puppet::Util::Windows::File::FILE_ALL_ACCESS)
-      protect = true
-      expected_sd = Puppet::Util::Windows::SecurityDescriptor.new(admins, admins, dacl, protect)
-      Puppet::Util::Windows::Security.set_security_descriptor(file, expected_sd)
-
-      ignored_mode = 0644
-      Puppet::Util.replace_file(file, ignored_mode) do |temp_file|
-        ignored_sd = Puppet::Util::Windows::Security.get_security_descriptor(temp_file.path)
-        users = 'S-1-5-11'
-        ignored_sd.dacl.allow(users, Puppet::Util::Windows::File::FILE_GENERIC_READ)
-        Puppet::Util::Windows::Security.set_security_descriptor(temp_file.path, ignored_sd)
-      end
-
-      replaced_sd = Puppet::Util::Windows::Security.get_security_descriptor(file)
-
-      expect(replaced_sd.dacl).to eq(expected_sd.dacl)
-    end
-
-    it "replace_file should use reasonable default ACEs on a new file on Windows" do
-
-      dir = tmpdir('DACL_playground')
-      protected_sd = Puppet::Util::Windows::Security.get_security_descriptor(dir)
-      protected_sd.protect = true
-      Puppet::Util::Windows::Security.set_security_descriptor(dir, protected_sd)
-
-      sibling_path = File.join(dir, 'sibling_file')
-      FileUtils.touch(sibling_path)
-
-      expected_sd = Puppet::Util::Windows::Security.get_security_descriptor(sibling_path)
-
-      new_file_path = File.join(dir, 'new_file')
-
-      ignored_mode = nil
-      Puppet::Util.replace_file(new_file_path, ignored_mode) { |tmp_file| }
-
-      new_sd = Puppet::Util::Windows::Security.get_security_descriptor(new_file_path)
-
-      expect(new_sd.dacl).to eq(expected_sd.dacl)
-    end
-
-    it "replace_file should work with filenames that include - and . (PUP-1389)" do
-      expected_content = 'some content'
-      dir = tmpdir('ReplaceFile_playground')
-      destination_file = File.join(dir, 'some-file.xml')
-
-      Puppet::Util.replace_file(destination_file, nil) do |temp_file|
-          temp_file.open
-          temp_file.write(expected_content)
-      end
-
-      actual_content = File.read(destination_file)
-      expect(actual_content).to eq(expected_content)
-    end
-
-    it "replace_file should work with filenames that include special characters (PUP-1389)" do
-      expected_content = 'some content'
-      dir = tmpdir('ReplaceFile_playground')
-      # http://www.fileformat.info/info/unicode/char/00e8/index.htm
-      # dest_name = "somèfile.xml"
-      dest_name = "som\u00E8file.xml"
-      destination_file = File.join(dir, dest_name)
-
-      Puppet::Util.replace_file(destination_file, nil) do |temp_file|
-          temp_file.open
-          temp_file.write(expected_content)
-      end
-
-      actual_content = File.read(destination_file)
-      expect(actual_content).to eq(expected_content)
-    end
-  end
-
-  describe "#which on Windows", :if => Puppet::Util::Platform.windows? do
-    let (:rune_utf8) { "\u16A0\u16C7\u16BB\u16EB\u16D2\u16E6\u16A6\u16EB\u16A0\u16B1\u16A9\u16A0\u16A2\u16B1\u16EB\u16A0\u16C1\u16B1\u16AA\u16EB\u16B7\u16D6\u16BB\u16B9\u16E6\u16DA\u16B3\u16A2\u16D7" }
-    let (:filename) { 'foo.exe' }
-
-    it "should be able to use UTF8 characters in the path" do
-      utf8 = tmpdir(rune_utf8)
-      Puppet::FileSystem.mkpath(utf8)
-
-      filepath = File.join(utf8, filename)
-      Puppet::FileSystem.touch(filepath)
-
-      path = [utf8, "c:\\windows\\system32", "c:\\windows"].join(File::PATH_SEPARATOR)
-      Puppet::Util.withenv( { "PATH" => path } , :windows) do
-        expect(Puppet::Util.which(filename)).to eq(filepath)
-      end
-    end
-  end
-end

data/spec/lib/matchers/containment_matchers.rb

@@ -1,52 +0,0 @@
-module ContainmentMatchers
-  class ContainClass
-    def initialize(containee)
-      @containee = containee
-    end
-
-    def in(container)
-      @container = container
-      self
-    end
-
-    def matches?(catalog)
-      @catalog = catalog
-
-      raise ArgumentError, "You must set the container using #in" unless @container
-
-      @container_resource = catalog.resource("Class", @container)
-      @containee_resource = catalog.resource("Class", @containee)
-
-      if @containee_resource && @container_resource
-        catalog.edge?(@container_resource, @containee_resource)
-      else
-        false
-      end
-    end
-
-    def failure_message
-      message = "Expected #{@catalog.to_dot} to contain Class #{@containee.inspect} inside of Class #{@container.inspect} but "
-
-      missing = []
-      if @container_resource.nil?
-        missing << @container
-      end
-      if @containee_resource.nil?
-        missing << @containee
-      end
-
-      if ! missing.empty?
-        message << "the catalog does not contain #{missing.map(&:inspect).join(' or ')}"
-      else
-        message << "no containment relationship exists"
-      end
-
-      message
-    end
-  end
-
-  # expect(catalog).to contain_class(containee).in(container)
-  def contain_class(containee)
-    ContainClass.new(containee)
-  end
-end

data/spec/lib/matchers/include_in_order.rb

@@ -1,20 +0,0 @@
-RSpec::Matchers.define :include_in_order do |*expected|
-
-  match do |actual|
-    elements = expected.dup
-    actual.each do |elt|
-      if elt == elements.first
-        elements.shift
-      end
-    end
-    elements.empty?
-  end
-
-  def failure_message
-    "expected #{@actual.inspect} to include#{expected} in order"
-  end
-
-  def failure_message_when_negated
-    "expected #{@actual.inspect} not to include#{expected} in order"
-  end
-end

data/spec/lib/matchers/include_in_order_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-require 'matchers/include_in_order'
-
-describe "Matching whether elements are included in order" do
-  context "an empty array" do
-    it "is included in an empty array" do
-      expect([]).to include_in_order()
-    end
-
-    it "is included in a non-empty array" do
-      expect([1]).to include_in_order()
-    end
-  end
-
-  it "[1,2,3] is included in [0,1,2,3,4]" do
-    expect([0,1,2,3,4]).to include_in_order(1,2,3)
-  end
-
-  it "[2,1] is not included in order in [1,2]" do
-    expect([1,2]).not_to include_in_order(2,1)
-  end
-
-  it "[2,4,6] is included in order in [1,2,3,4,5,6]" do
-    expect([1,2,3,4,5,6]).to include_in_order(2,4,6)
-  end
-
-  it "overlapping ordered array is not included" do
-    expect([1,2,3]).not_to include_in_order(2,3,4)
-  end
-end

data/spec/lib/matchers/json.rb

@@ -1,132 +0,0 @@
-module JSONMatchers
-  class SetJsonAttribute
-    def initialize(attributes)
-      @attributes = attributes
-    end
-
-    def format
-      @format ||= Puppet::Network::FormatHandler.format('json')
-    end
-
-    def json(instance)
-      Puppet::Util::Json.load(instance.to_json)
-    end
-
-    def attr_value(attrs, instance)
-      attrs = attrs.dup
-      hash = json(instance)
-      while attrs.length > 0
-        name = attrs.shift
-        hash = hash[name]
-      end
-      hash
-    end
-
-    def to(value)
-      @value = value
-      self
-    end
-
-    def matches?(instance)
-      @instance = instance
-      result = attr_value(@attributes, instance)
-      if @value
-        result == @value
-      else
-        ! result.nil?
-      end
-    end
-
-    def failure_message
-      if @value
-        "expected #{@instance.inspect} to set #{@attributes.inspect} to #{@value.inspect}; got #{attr_value(@attributes, @instance).inspect}"
-      else
-        "expected #{@instance.inspect} to set #{@attributes.inspect} but was nil"
-      end
-    end
-
-    def failure_message_when_negated
-      if @value
-        "expected #{@instance.inspect} not to set #{@attributes.inspect} to #{@value.inspect}"
-      else
-        "expected #{@instance.inspect} not to set #{@attributes.inspect} to nil"
-      end
-    end
-  end
-
-  class ReadJsonAttribute
-    def initialize(attribute)
-      @attribute = attribute
-    end
-
-    def format
-      @format ||= Puppet::Network::FormatHandler.format('json')
-    end
-
-    def from(value)
-      @json = value
-      self
-    end
-
-    def as(as)
-      @value = as
-      self
-    end
-
-    def matches?(klass)
-      raise "Must specify json with 'from'" unless @json
-      @klass = klass
-      @instance = format.intern(klass, @json)
-      if @value
-        @instance.send(@attribute) == @value
-      else
-        ! @instance.send(@attribute).nil?
-      end
-    end
-
-    def failure_message
-      if @value
-        "expected #{@klass} to read #{@attribute} from #{@json} as #{@value.inspect}; got #{@instance.send(@attribute).inspect}"
-      else
-        "expected #{@klass} to read #{@attribute} from #{@json} but was nil"
-      end
-    end
-
-    def failure_message_when_negated
-      if @value
-        "expected #{@klass} not to set #{@attribute} to #{@value}"
-      else
-        "expected #{@klass} not to set #{@attribute} to nil"
-      end
-    end
-  end
-
-  require 'puppet/util/json'
-  require 'json-schema'
-
-  class SchemaMatcher
-    JSON_META_SCHEMA = Puppet::Util::Json.load(File.read('api/schemas/json-meta-schema.json'))
-
-    def initialize(schema)
-      @schema = schema
-    end
-
-    def matches?(json)
-      JSON::Validator.validate!(JSON_META_SCHEMA, @schema)
-      JSON::Validator.validate!(@schema, json)
-    end
-  end
-
-  def validate_against(schema_file)
-    schema = Puppet::Util::Json.load(File.read(schema_file))
-    SchemaMatcher.new(schema)
-  end
-
-  def set_json_attribute(*attributes)
-    SetJsonAttribute.new(attributes)
-  end
-
-  def read_json_attribute(attribute)
-    ReadJsonAttribute.new(attribute)
-  end
-end

data/spec/lib/matchers/match_tokens2.rb

@@ -1,74 +0,0 @@
-# Matches tokens produced by lexer
-# The given exepected is one or more entries where an entry is one of
-# - a token symbol
-# - an Array with a token symbol and the text value
-# - an Array with a token symbol and a Hash specifying all attributes of the token
-# - nil (ignore)
-#
-RSpec::Matchers.define :match_tokens2 do | *expected |
-  match do | actual |
-    expected.zip(actual).all? do |e, a|
-      compare(e, a)
-    end
-  end
-
-  def failure_message
-    msg = ["Expected (#{expected.size}):"]
-    expected.each {|e| msg << e.to_s }
-
-    zipped = expected.zip(actual)
-    msg << "\nGot (#{actual.size}):"
-    actual.each_with_index do |e, idx|
-      if zipped[idx]
-        zipped_expected = zipped[idx][0]
-        zipped_actual = zipped[idx][1]
-
-        prefix = compare(zipped_expected, zipped_actual) ? ' ' : '*'
-        msg2 = ["#{prefix}[:"]
-        msg2 << e[0].to_s
-        msg2 << ', '
-        if e[1] == false
-          msg2 << 'false'
-        else
-          msg2 << e[1][:value].to_s.dump
-        end
-        # If expectation has options, output them
-        if zipped_expected.is_a?(Array) && zipped_expected[2] && zipped_expected[2].is_a?(Hash)
-          msg2 << ", {"
-          msg3 = []
-          zipped_expected[2].each do |k,v|
-            prefix = e[1][k] != v ? "*" : ''
-            msg3 << "#{prefix}:#{k}=>#{e[1][k]}"
-          end
-          msg2 << msg3.join(", ")
-          msg2 << "}"
-        end
-        msg2 << ']'
-        msg << msg2.join('')
-      end
-    end
-    msg.join("\n")
-  end
-
-  def compare(e, a)
-    # if expected ends before actual
-    return true if !e
-
-    # If actual ends before expected
-    return false if !a
-
-    # Simple - only expect token to match
-    return true if a[0] == e
-
-    # Expect value and optional attributes to match
-    if e.is_a? Array
-      # tokens must match
-      return false unless a[0] == e[0]
-      if e[2].is_a?(Hash)
-        e[2].each {|k,v| return false unless a[1][k] == v }
-      end
-      return (a[1] == e[1] || (a[1][:value] == e[1]))
-    end
-    false
-  end
-end

data/spec/lib/matchers/relationship_graph_matchers.rb

@@ -1,48 +0,0 @@
-module RelationshipGraphMatchers
-  class EnforceOrderWithEdge
-    def initialize(before, after)
-      @before = before
-      @after = after
-    end
-
-    def matches?(actual_graph)
-      @actual_graph = actual_graph
-
-      @reverse_edge = actual_graph.edge?(
-          vertex_called(actual_graph, @after),
-          vertex_called(actual_graph, @before))
-
-      @forward_edge = actual_graph.edge?(
-          vertex_called(actual_graph, @before),
-          vertex_called(actual_graph, @after))
-
-      @forward_edge && !@reverse_edge
-    end
-
-    def failure_message
-      "expect #{@actual_graph.to_dot_graph} to only contain an edge from #{@before} to #{@after} but #{[forward_failure_message, reverse_failure_message].compact.join(' and ')}"
-    end
-
-    def forward_failure_message
-      if !@forward_edge
-        "did not contain an edge from #{@before} to #{@after}"
-      end
-    end
-
-    def reverse_failure_message
-      if @reverse_edge
-        "contained an edge from #{@after} to #{@before}"
-      end
-    end
-
-    private
-
-    def vertex_called(graph, name)
-      graph.vertices.find { |v| v.ref =~ /#{Regexp.escape(name)}/ }
-    end
-  end
-
-  def enforce_order_with_edge(before, after)
-    EnforceOrderWithEdge.new(before, after)
-  end
-end