com.hubspot.jinjava.Jinjava Java Examples

@VisibleForTesting
String sparkUiWebUrlFromTemplate(String templateString, int port, String serviceName, String serviceDomain) {
  ImmutableMap<String, Object> binding = ImmutableMap.of(
      "PORT", port,
      "SERVICE_NAME", serviceName,
      ENV_SERVICE_DOMAIN, serviceDomain
  );

  ClassLoader oldCl = Thread.currentThread().getContextClassLoader();
  try {
    Thread.currentThread().setContextClassLoader(this.getClass().getClassLoader());
    Jinjava jinja = new Jinjava();
    return jinja.render(templateString, binding);
  } finally {
    Thread.currentThread().setContextClassLoader(oldCl);
  }
}
 

@Test
public void itAddsAllDeferredNodesOfGlobalImport() {
  Jinjava jinjava = new Jinjava();
  interpreter = new JinjavaInterpreter(jinjava, context, jinjava.getGlobalConfig());
  interpreter.getContext().put("primary_font_size_num", DeferredValue.instance());
  fixture("import-property-global");
  Set<String> deferredImages = interpreter
    .getContext()
    .getDeferredNodes()
    .stream()
    .map(Node::reconstructImage)
    .collect(Collectors.toSet());
  assertThat(
      deferredImages
        .stream()
        .filter(image -> image.contains("{% set primary_line_height"))
        .collect(Collectors.toSet())
    )
    .isNotEmpty();
}
 

@Test
public void itAvoidsNestedImportCycle() throws IOException {
  Jinjava jinjava = new Jinjava();
  interpreter = new JinjavaInterpreter(jinjava, context, jinjava.getGlobalConfig());

  interpreter.render(
    Resources.toString(
      Resources.getResource("tags/importtag/a-imports-b.jinja"),
      StandardCharsets.UTF_8
    )
  );
  assertThat(context.get("a")).isEqualTo("foo");
  assertThat(context.get("b")).isEqualTo("bar");

  assertThat(interpreter.getErrorsCopy().get(0).getMessage())
    .contains("Import cycle detected", "b-imports-a.jinja");
}
 

@Test
public void testUnorderedArgsAndKwargs() {
  jinjava = new Jinjava();

  Object[] expectedArgs = new Object[] { "1", 2L };
  Map<String, Object> expectedKwargs = new HashMap<String, Object>() {

    {
      put("named", "test");
    }
  };

  jinjava
    .getGlobalContext()
    .registerFilter(new MyMirrorFilter(expectedArgs, expectedKwargs));

  assertThat(
      jinjava.render("{{ 'test'|mirror('1', named='test', 2) }}", new HashMap<>())
    )
    .isEqualTo("test");
}
 

private String testTemplate(String path) {
  String template = resource(path);

  Jinjava jinjava = new Jinjava();
  return jinjava.render(
      template,
      ImmutableMap.<String, Object>builder()
          .put("gradleHome", testGradleHome.toAbsolutePath().toString().replace('\\', '/'))
          .put("jdkFolder", "jdk-zulu13.28.11-ca-jdk13.0.1")
          .put("javaVersion", "zulu13.28.11-ca-jdk13.0.1")
          .put(
              "jdk8Folder", "zulu8.42.0.21-ca-jdk8.0.232/zulu8.42.0.21-ca-jdk8.0.232-" + suffix())
          .put("java8Version", "zulu8.42.0.21-ca-jdk8.0.232")
          .put("goVersion", ToolDependencies.getDefaultVersion("golang"))
          .build());
}
 

@Test
public void testOnlyKwargs() {
  jinjava = new Jinjava();

  Object[] expectedArgs = new Object[] {};
  Map<String, Object> expectedKwargs = new HashMap<String, Object>() {

    {
      put("named10", "str");
      put("named2", 3L);
      put("namedB", true);
    }
  };

  jinjava
    .getGlobalContext()
    .registerFilter(new MyMirrorFilter(expectedArgs, expectedKwargs));

  assertThat(
      jinjava.render(
        "{{ 'test'|mirror(named2=3, named10='str', namedB=true) }}",
        new HashMap<>()
      )
    )
    .isEqualTo("test");
}
 

public void createUsageUI() {
  try {
    List<CommandlineOption> commandlineOptions = getCommandlineOptions();
    HashMap<String, Object> mapParams = new HashMap();
    mapParams.put(unifyKey(SubmarineConstants.PARAGRAPH_ID), intpContext.getParagraphId());
    mapParams.put(SubmarineConstants.COMMANDLINE_OPTIONS, commandlineOptions);

    URL urlTemplate = Resources.getResource(SUBMARINE_USAGE_JINJA);
    String template = Resources.toString(urlTemplate, Charsets.UTF_8);
    Jinjava jinjava = new Jinjava();
    String submarineUsage = jinjava.render(template, mapParams);

    InterpreterResultMessageOutput outputUI = intpContext.out.getOutputAt(0);
    outputUI.clear();
    outputUI.write(submarineUsage);
    outputUI.flush();

    // UI update, log needs to be cleaned at the same time
    InterpreterResultMessageOutput outputLOG = intpContext.out.getOutputAt(1);
    outputLOG.clear();
    outputLOG.flush();
  } catch (IOException e) {
    LOGGER.error("Can't print usage", e);
  }
}
 

public void createLogHeadUI() {
  try {
    HashMap<String, Object> mapParams = new HashMap();
    URL urlTemplate = Resources.getResource(SUBMARINE_LOG_HEAD_JINJA);
    String template = Resources.toString(urlTemplate, Charsets.UTF_8);
    Jinjava jinjava = new Jinjava();
    String submarineUsage = jinjava.render(template, mapParams);

    InterpreterResultMessageOutput outputUI = intpContext.out.getOutputAt(1);
    outputUI.clear();
    outputUI.write(submarineUsage);
    outputUI.flush();
  } catch (IOException e) {
    LOGGER.error("Can't print usage", e);
  }
}
 

public void printCommnadUI(SubmarineCommand submarineCmd) {
  try {
    HashMap<String, Object> mapParams = new HashMap();
    mapParams.put(unifyKey(SubmarineConstants.PARAGRAPH_ID), intpContext.getParagraphId());

    URL urlTemplate = Resources.getResource(SUBMARINE_DASHBOARD_JINJA);
    String template = Resources.toString(urlTemplate, Charsets.UTF_8);
    Jinjava jinjava = new Jinjava();
    String submarineUsage = jinjava.render(template, mapParams);

    InterpreterResultMessageOutput outputUI = intpContext.out.getOutputAt(0);
    outputUI.clear();
    outputUI.write(submarineUsage);
    outputUI.flush();

    // UI update, log needs to be cleaned at the same time
    InterpreterResultMessageOutput outputLOG = intpContext.out.getOutputAt(1);
    outputLOG.clear();
    outputLOG.flush();
  } catch (IOException e) {
    LOGGER.error("Can't print usage", e);
  }
}
 

@Test
public void itLimitsOutputSizeWhenSumOfNodeSizesExceedsMax() {
  JinjavaConfig outputSizeLimitedConfig = JinjavaConfig
    .newBuilder()
    .withMaxOutputSize(19)
    .build();
  String input = "1234567890{% block testchild %}1234567890{% endblock %}";
  String output = "12345678901234567890"; // Note that this exceeds the max size

  RenderResult renderResult = new Jinjava().renderForResult(input, new HashMap<>());
  assertThat(renderResult.getOutput()).isEqualTo(output);
  assertThat(renderResult.hasErrors()).isFalse();

  renderResult =
    new Jinjava(outputSizeLimitedConfig).renderForResult(input, new HashMap<>());
  assertThat(renderResult.hasErrors()).isTrue();
  assertThat(renderResult.getErrors().get(0).getMessage())
    .contains("OutputTooBigException");
}
 

@Before
public void setUp() throws Exception {
  interpreter = new Jinjava().newInterpreter();

  locatorWorkingDir = new FileLocator();

  File tmpDir = java
    .nio.file.Files.createTempDirectory(getClass().getSimpleName())
    .toFile();
  locatorTmpDir = new FileLocator(tmpDir);

  first = new File(tmpDir, "foo/first.jinja");
  second = new File("target/loader-test-data/second.jinja");

  first.getParentFile().mkdirs();
  second.getParentFile().mkdirs();

  Files.write("first", first, StandardCharsets.UTF_8);
  Files.write("second", second, StandardCharsets.UTF_8);
}
 

@Test
public void itDoesNotRenderTagsDependingOnDeferredGlobalImport() {
  try {
    Jinjava jinjava = new Jinjava();
    interpreter = new JinjavaInterpreter(jinjava, context, jinjava.getGlobalConfig());
    interpreter.getContext().put("primary_font_size_num", DeferredValue.instance());
    String renderedImport = fixture("import-property");
    assertThat(renderedImport)
      .isEqualTo(
        Resources.toString(
          Resources.getResource("tags/macrotag/import-property.jinja"),
          StandardCharsets.UTF_8
        )
      );
  } catch (IOException e) {
    throw new RuntimeException();
  }
}
 

@Test
public void itAllowsMacroRecursionWithMaxDepth() throws IOException {
  interpreter =
    new Jinjava(
      JinjavaConfig
        .newBuilder()
        .withEnableRecursiveMacroCalls(true)
        .withMaxMacroRecursionDepth(10)
        .build()
    )
    .newInterpreter();
  JinjavaInterpreter.pushCurrent(interpreter);

  try {
    String template = fixtureText("ending-recursion");
    String out = interpreter.render(template);
    assertThat(interpreter.getErrorsCopy()).isEmpty();
    assertThat(out).contains("Hello Hello Hello Hello Hello");
  } finally {
    JinjavaInterpreter.popCurrent();
  }
}
 

@Test
public void itAllowsMacroRecursionWhenEnabledInConfiguration() throws IOException {
  // I need a different configuration here therefore
  interpreter =
    new Jinjava(JinjavaConfig.newBuilder().withEnableRecursiveMacroCalls(true).build())
    .newInterpreter();
  JinjavaInterpreter.pushCurrent(interpreter);

  try {
    String template = fixtureText("ending-recursion");
    String out = interpreter.render(template);
    assertThat(interpreter.getErrorsCopy()).isEmpty();
    assertThat(out).contains("Hello Hello Hello Hello Hello");
  } finally {
    // and I need to cleanup my mess...
    JinjavaInterpreter.popCurrent();
  }
}
 

@Before
public void setup() {
  jinjava = new Jinjava();
  jinjava
    .getGlobalContext()
    .put(
      "users",
      Lists.newArrayList(
        new User(0, false, "[email protected]", new Option(0, "option0")),
        new User(1, true, "[email protected]", new Option(1, "option1")),
        new User(2, false, null, new Option(2, "option2"))
      )
    );
}
 

private Map<String, String> renderFiles(Map<String, Object> context, Map<String, String> files) throws FatalTemplateErrorsException {
    Jinjava jinjava = new Jinjava();
    Map<String, String> targetFiles = new HashMap<>();

    files.forEach((key, value) -> {
        String renderedContent = jinjava.render(value, context);
        targetFiles.put(key, Base64.getEncoder().encodeToString(renderedContent.getBytes()));
    });

    return targetFiles;
}
 

@Before
public void setup() {
  jinjava = new Jinjava();

  bindings = new HashMap<>();
  bindings.put("var1", new Integer[] { 23, 45, 45, 689 });
  bindings.put("var2", "45");
  bindings.put("var3", 12);
  bindings.put("var5", "");
}
 

@Before
public void setup() {
  jinjava = new Jinjava();
  jinjava
    .getGlobalContext()
    .put(
      "users",
      Lists.newArrayList(
        new User(0, false, "[email protected]", new Option(0, "option0")),
        new User(1, true, "[email protected]", new Option(1, "option1")),
        new User(2, false, null, new Option(2, "option2"))
      )
    );
}
 

@Before
public void setup() {
  interpreter = new Jinjava().newInterpreter();
  JinjavaInterpreter.pushCurrent(interpreter);

  context = interpreter.getContext();
}
 

public JinjavaInterpreter(
  Jinjava application,
  Context context,
  JinjavaConfig renderConfig
) {
  this.context = context;
  this.config = renderConfig;
  this.application = application;

  switch (config.getRandomNumberGeneratorStrategy()) {
    case THREAD_LOCAL:
      random = ThreadLocalRandom.current();
      break;
    case CONSTANT_ZERO:
      random = new ConstantZeroRandomNumberGenerator();
      break;
    case DEFERRED:
      random = new DeferredRandomNumberGenerator();
      break;
    default:
      throw new IllegalStateException(
        "No random number generator with strategy " +
        config.getRandomNumberGeneratorStrategy()
      );
  }

  this.expressionResolver =
    new ExpressionResolver(this, application.getExpressionFactory());
}
 

@Test
public void itRendersWithNestedExpressionInterpretationByDefault() throws Exception {
  final JinjavaConfig config = JinjavaConfig.newBuilder().build();
  JinjavaInterpreter noNestedInterpreter = new Jinjava(config).newInterpreter();
  Context contextNoNestedInterpretation = noNestedInterpreter.getContext();
  contextNoNestedInterpretation.put("myvar", "hello {{ place }}");
  contextNoNestedInterpretation.put("place", "world");

  ExpressionNode node = fixture("simplevar");
  assertThat(node.render(noNestedInterpreter).toString()).isEqualTo("hello world");
}
 

@Test
public void itFailsOnUnknownTokensVariables() throws Exception {
  final JinjavaConfig config = JinjavaConfig
    .newBuilder()
    .withFailOnUnknownTokens(true)
    .build();
  JinjavaInterpreter jinjavaInterpreter = new Jinjava(config).newInterpreter();

  String jinja = "{{ UnknownToken }}";
  Node node = new TreeParser(jinjavaInterpreter, jinja).buildTree();
  assertThatThrownBy(() -> jinjavaInterpreter.render(node))
    .isInstanceOf(UnknownTokenException.class)
    .hasMessage("Unknown token found: UnknownToken");
}
 

@Test
public void itFailsOnUnknownTokensOfIf() throws Exception {
  final JinjavaConfig config = JinjavaConfig
    .newBuilder()
    .withFailOnUnknownTokens(true)
    .build();
  JinjavaInterpreter jinjavaInterpreter = new Jinjava(config).newInterpreter();

  String jinja = "{% if bad  %} BAD {% endif %}";
  Node node = new TreeParser(jinjavaInterpreter, jinja).buildTree();
  assertThatThrownBy(() -> jinjavaInterpreter.render(node))
    .isInstanceOf(UnknownTokenException.class)
    .hasMessageContaining("Unknown token found: bad");
}
 

@Test
public void itFailsOnUnknownTokensWithFilter() throws Exception {
  final JinjavaConfig config = JinjavaConfig
    .newBuilder()
    .withFailOnUnknownTokens(true)
    .build();
  JinjavaInterpreter jinjavaInterpreter = new Jinjava(config).newInterpreter();

  String jinja = "{{ UnknownToken }}";
  Node node = new TreeParser(jinjavaInterpreter, jinja).buildTree();
  assertThatThrownBy(() -> jinjavaInterpreter.render(node))
    .isInstanceOf(UnknownTokenException.class)
    .hasMessage("Unknown token found: UnknownToken");
}
 

@Test
public void trimAndLstripBlocks() {
  interpreter =
    new Jinjava(
      JinjavaConfig.newBuilder().withLstripBlocks(true).withTrimBlocks(true).build()
    )
    .newInterpreter();

  assertThat(interpreter.render(parse("parse/tokenizer/whitespace-tags.jinja")))
    .isEqualTo("<div>\n" + "        yay\n" + "</div>\n");
}
 

@Before
public void setup() {
  config =
    JinjavaConfig.newBuilder().withTokenScannerSymbols(new CustomTokens()).build();
  jinjava = new Jinjava(config);
  jinjava.getGlobalContext().put("numbers", Lists.newArrayList(1L, 2L, 3L, 4L, 5L));
}
 

@Before
public void setUp() {
  JinjavaConfig.Builder builder = JinjavaConfig.newBuilder();
  builder.withFailOnUnknownTokens(true);
  JinjavaConfig config = builder.build();
  jinjava = new Jinjava(config);
}
 

@Before
public void setup() {
  jinjava = new Jinjava();
  jinjava
    .getGlobalContext()
    .put("users", Lists.newArrayList(new User("foo"), new User("bar")));
}
 

@Test
public void itIncludesFileViaRelativePath() throws IOException {
  jinjava = new Jinjava();
  jinjava.setResourceLocator(
    new ResourceLocator() {
      private RelativePathResolver relativePathResolver = new RelativePathResolver();

      @Override
      public String getString(
        String fullName,
        Charset encoding,
        JinjavaInterpreter interpreter
      )
        throws IOException {
        return Resources.toString(
          Resources.getResource(String.format("%s", fullName)),
          StandardCharsets.UTF_8
        );
      }

      @Override
      public Optional<LocationResolver> getLocationResolver() {
        return Optional.of(relativePathResolver);
      }
    }
  );

  jinjava
    .getGlobalContext()
    .put(CURRENT_PATH_CONTEXT_KEY, "tags/includetag/includes-relative-path.jinja");
  RenderResult result = jinjava.renderForResult(
    Resources.toString(
      Resources.getResource("tags/includetag/includes-relative-path.jinja"),
      StandardCharsets.UTF_8
    ),
    new HashMap<>()
  );

  assertThat(result.getOutput().trim()).isEqualTo("INCLUDED");
}
 

@Test
public void itSetsFieldNameCaseForSyntaxErrorInFor() {
  RenderResult renderResult = new Jinjava()
  .renderForResult("{% for item inna navigation %}{% endfor %}", ImmutableMap.of());
  assertThat(renderResult.getErrors().get(0).getFieldName())
    .isEqualTo("item inna navigation");
}