How to use

FiltersSpecifier

in

org.batfish.datamodel.questions

@Test
public void constructorIpv4() {
 FiltersSpecifier specifier = new FiltersSpecifier("ipv4:secret.*");
 assertThat(specifier.getType(), equalTo(Type.IPV4));
 assertThat(specifier.getRegex().pattern(), equalTo(Pattern.compile("secret.*").pattern()));
}

 @Override
 public Set<IpAccessList> resolve(String node, SpecifierContext ctxt) {
  checkArgument(
    ctxt.getConfigs().containsKey(node),
    "SpecifierContext does not have configs for node: " + node);
  Configuration config = ctxt.getConfigs().get(node);
  return config.getIpAccessLists().values().stream()
    .filter(filter -> _shorthandSpecifier.matches(filter, config))
    .collect(Collectors.toSet());
 }
}

/**
 * Evaluates if the given IPv4 filter matches this specifier
 *
 * @param filter The filter to evaluate
 * @param c The configuration providing context in which to evaluate
 * @return Results of the match
 */
public boolean matches(IpAccessList filter, Configuration c) {
 switch (_type) {
  case INPUTFILTERON:
   return isFilterOnInterface(c, Interface::getIncomingFilter, filter);
  case IPV4:
   return _regex.matcher(filter.getName()).matches();
  case IPV6:
   return false;
  case NAME:
   return _regex.matcher(filter.getName()).matches();
  case OUTPUTFILTERON:
   return isFilterOnInterface(c, Interface::getOutgoingFilter, filter);
  default:
   throw new BatfishException("Unhandled FiltersSpecifier type: " + _type);
 }
}

 @Override
 public FilterSpecifier buildFilterSpecifier(@Nullable Object input) {
  if (input == null) {
   return new ShorthandFilterSpecifier(FiltersSpecifier.ALL);
  }
  checkArgument(input instanceof String, "String input required for " + getName());
  FiltersSpecifier specifier = new FiltersSpecifier(input.toString().trim());
  checkArgument(specifier.getType() != Type.IPV6, "IPv6 is not currently supported");
  return new ShorthandFilterSpecifier(specifier);
 }
}

@Test
public void matchesIpv4() {
 FiltersSpecifier specifier = new FiltersSpecifier("ipv4:acl.*");
 IpAccessList matchingList = new IpAccessList("acl-99");
 Ip6AccessList nonMatchingList = new Ip6AccessList("acl-99");
 assertThat(specifier.matches(matchingList, null), equalTo(true));
 assertThat(specifier.matches(nonMatchingList), equalTo(false));
}

 @Test
 public void conversionToAndFrom() {
  FilterGroup group =
    new FilterGroup(
      ImmutableList.of(new FiltersSpecifier("abc"), new FiltersSpecifier("ipv4:def")), "fg1");
  FilterGroupBean bean = new FilterGroupBean(group);
  assertThat(new FilterGroupBean(bean.toFilterGroup()), equalTo(bean));
 }
}

@Test
public void matchesName() {
 FiltersSpecifier specifier = new FiltersSpecifier("name:acl.*");
 IpAccessList matchingList = new IpAccessList("acl-99");
 IpAccessList nonMatchingList = new IpAccessList("nana");
 assertThat(specifier.matches(matchingList, null), equalTo(true));
 assertThat(specifier.matches(nonMatchingList, null), equalTo(false));
}

@Test
public void resolve() {
 assertThat(
   new ShorthandFilterSpecifier(new FiltersSpecifier(_filter1.getName()))
     .resolve(_nodeName, _ctxt),
   equalTo(ImmutableSet.of(_filter1)));
}

 @Test
 public void nameWithColons() {
  String expression = "foo::bar::baz";
  FiltersSpecifier specifier = new FiltersSpecifier("name:" + expression);
  assertThat(specifier.getType(), is(Type.NAME));
  assertThat(specifier.getRegex().pattern(), equalTo(expression));
 }
}

@Test
public void matchesFilterOn() {
 String inAclName = "inAcl";
 String outAclName = "outAcl";
 NetworkFactory nf = new NetworkFactory();
 Configuration c =
   nf.configurationBuilder().setConfigurationFormat(ConfigurationFormat.CISCO_IOS).build();
 Vrf v = nf.vrfBuilder().setOwner(c).build();
 IpAccessList inAcl = IpAccessList.builder().setName(inAclName).setOwner(c).build();
 IpAccessList outAcl = IpAccessList.builder().setName(outAclName).setOwner(c).build();
 Interface i =
   nf.interfaceBuilder()
     .setIncomingFilter(inAcl)
     .setOutgoingFilter(outAcl)
     .setOwner(c)
     .setVrf(v)
     .build();
 String iName = i.getName();
 FiltersSpecifier inputFilterSpecifier =
   new FiltersSpecifier(String.format("%s:%s", Type.INPUTFILTERON.name(), iName));
 FiltersSpecifier outputFilterSpecifier =
   new FiltersSpecifier(String.format("%s:%s", Type.OUTPUTFILTERON.name(), iName));
 assertThat(inputFilterSpecifier.matches(inAcl, c), equalTo(true));
 assertThat(inputFilterSpecifier.matches(outAcl, c), equalTo(false));
 assertThat(outputFilterSpecifier.matches(outAcl, c), equalTo(true));
 assertThat(outputFilterSpecifier.matches(inAcl, c), equalTo(false));
}

/**
 * Check that if a simple string is the specifier input, that maps to the expected
 * FilterSpecifier. (That this happens is being assumed by SearchFiltersAnswerer, which it ideally
 * shouldn't but in the meanwhile this test helps.)
 */
@Test
public void testDefaultSpecifierInput() {
 TestFiltersQuestion question = new TestFiltersQuestion(null, "acl", null, null);
 assertThat(
   question.getFilterSpecifier(),
   equalTo(new ShorthandFilterSpecifier(new FiltersSpecifier("acl"))));
}

 @Override
 public Set<IpAccessList> resolve(String node, SpecifierContext ctxt) {
  checkArgument(
    ctxt.getConfigs().containsKey(node),
    "SpecifierContext does not have configs for node " + node);
  Configuration config = ctxt.getConfigs().get(node);

  FilterGroup filterGroup =
    ctxt.getReferenceBook(_bookName)
      .orElseThrow(
        () -> new NoSuchElementException("ReferenceBook '" + _bookName + "' not found"))
      .getFilterGroup(_filterGroupName)
      .orElseThrow(
        () ->
          new NoSuchElementException(
            "FilterGroup '"
              + _filterGroupName
              + "' not found in ReferenceBook '"
              + _bookName
              + "'"));

  return config.getIpAccessLists().values().stream()
    .filter(
      filter ->
        filterGroup.getFilters().stream()
          .anyMatch(specifier -> specifier.matches(filter, config)))
    .collect(Collectors.toSet());
 }
}

@Test
public void constructorExplicitName() {
 FiltersSpecifier specifier = new FiltersSpecifier("name:acl.*");
 assertThat(specifier.getType(), equalTo(Type.NAME));
 assertThat(specifier.getRegex().pattern(), equalTo(Pattern.compile("acl.*").pattern()));
}

@Test
public void testNonNullInput() {
 assertThat(
   new ShorthandFilterSpecifierFactory().buildFilterSpecifier("filter1"),
   equalTo(new ShorthandFilterSpecifier(new FiltersSpecifier("filter1"))));
}

@Test
public void defaultWithColons() {
 String expression = "foo::bar::baz";
 FiltersSpecifier specifier = new FiltersSpecifier(expression);
 assertThat(specifier.getType(), is(Type.NAME));
 assertThat(specifier.getRegex().pattern(), equalTo(expression));
}

@Test
public void testShorthandFilterSpecifier() {
 assertThat(
   new FlexibleFilterSpecifierFactory().buildFilterSpecifier("ipv4:.*"),
   equalTo(new ShorthandFilterSpecifier(new FiltersSpecifier("ipv4:.*"))));
}

@Test
public void constructorImplicitName() {
 FiltersSpecifier specifier = new FiltersSpecifier("acl.*");
 assertThat(specifier.getType(), equalTo(Type.NAME));
 assertThat(specifier.getRegex().pattern(), equalTo(Pattern.compile("acl.*").pattern()));
}