ScenarioTests

package com.camunda.training;

import static org.assertj.core.api.Assertions.*;
import static org.assertj.core.api.Assertions.assertThat;
import static org.camunda.bpm.engine.test.assertions.bpmn.AbstractAssertions.*;
import static org.camunda.bpm.engine.test.assertions.bpmn.BpmnAwareTests.*;
import static org.camunda.bpm.engine.test.assertions.bpmn.BpmnAwareTests.assertThat;
import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.camunda.bpm.dmn.engine.DmnDecisionTableResult;
import org.camunda.bpm.engine.ProcessEngine;
import org.camunda.bpm.engine.runtime.Job;
import org.camunda.bpm.engine.runtime.ProcessInstance;
import org.camunda.bpm.engine.task.Task;
import org.camunda.bpm.engine.test.Deployment;
import org.camunda.bpm.engine.test.ProcessEngineRule;
import org.camunda.bpm.engine.test.mock.Mocks;
import org.camunda.bpm.engine.variable.Variables;
import org.camunda.bpm.extension.process_test_coverage.junit.rules.TestCoverageProcessEngineRuleBuilder;
import org.camunda.bpm.scenario.ProcessScenario;
import org.camunda.bpm.scenario.Scenario;
import org.junit.Before;
import org.junit.ClassRule;
import org.junit.Rule;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.springframework.beans.factory.annotation.Autowired;

import twitter4j.TwitterException;

public class ProcessJUnitTest {

    @Autowired
    ProcessEngine processEngine;

    @Mock
    ProcessScenario twitterScenario;

    @Mock
    TweetService tweetService;

    @Rule @ClassRule
    public static ProcessEngineRule rule = TestCoverageProcessEngineRuleBuilder.create().build();

    @Before
    public void setup() {
        init(rule.getProcessEngine());
        MockitoAnnotations.initMocks(this);
        Mocks.register("createTweetDelegate", new CreateTweetDelegate(tweetService));
    }

  @Test
  @Deployment(resources = {"tweetApproval.dmn", "exercise_1.bpmn"})
  public void testHappyPath() throws TwitterException {

        Mockito.when(tweetService.tweet(anyString())).thenReturn(101l);
        ProcessInstance processInstance = runtimeService().startProcessInstanceByKey("TwitterQAProcess", withVariables("content", "this is a test", "email","norman.luering@camunda.com"));
        assertThat(processInstance).isActive();
//      List<HistoricTaskInstance> histTasks = historyService().createHistoricTaskInstanceQuery().taskDefinitionKey("ReviewTweetTask").list();
//      HistoricTaskInstance histInstance = histTasks.get(0);
//      assertEquals(processInstance.getId(), histInstance.getProcessInstanceId());
        execute(job());
        assertThat(processInstance).isEnded();
  }

  @Test
  @Deployment(resources = "exercise_1.bpmn")
  public void testRejectedPath() {

      Map<String, Object> variables = new HashMap<String, Object>();
      variables.put("approved", false);
      ProcessInstance processInstance = runtimeService().
              createProcessInstanceByKey("TwitterQAProcess")
              .setVariablesLocal(variables)
              .startAfterActivity("ReviewTweetTask")
              .execute();

      assertThat(processInstance)
         .isWaitingAt("DeleteTweetTask")
         .externalTask()
         .hasTopicName("deleted");
      complete(externalTask());
      assertThat(processInstance).isEnded().hasPassed("TweetRejectedEndEvent");

  }

  @Test
  @Deployment(resources = {"tweetApproval.dmn", "exercise_1.bpmn"})
  public void testSuperUserTweet() {
        try {
            Mockito.when(tweetService.tweet(anyString())).thenReturn(101l);
        } catch (TwitterException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        ProcessInstance processInstance = runtimeService()
                .createMessageCorrelation("superuserTweet")
                .setVariable("content", "Secret Guys' Exercise 11 Tweet - " + System.currentTimeMillis())
                .correlateWithResult()
                .getProcessInstance();

        assertThat(processInstance).isStarted();

        List<Job> jobList = jobQuery().processInstanceId(processInstance.getId()).list();
        assertThat(jobList).hasSize(1);
        Job job = jobList.get(0);

        execute(job);
        assertThat(processInstance).isEnded();
  }

 // @Test
  @Deployment(resources = "exercise_1.bpmn")
  public void testTweetWithdrawn() {
    Map<String, Object> varMap = new HashMap<>();
    varMap.put("content", "Test tweetWithdrawn message");

    ProcessInstance processInstance = runtimeService()
        .startProcessInstanceByKey("TwitterQAProcess", varMap);

    assertThat(processInstance).isStarted().isWaitingAt("ReviewTweetTask");

    runtimeService()
       .createMessageCorrelation("tweetWithdrawn")
       .processInstanceVariableEquals("content", "Test tweetWithdrawn message")
       .correlateWithResult();

    assertThat(processInstance).isEnded();
  }

  @Test
  @Deployment(resources = {"tweetApproval.dmn", "exercise_1.bpmn"})
  public void testTweetsFromNorman() {

      Map<String, Object> variables = withVariables("email", "norman.luering@camunda.com", "content", "publish");
      DmnDecisionTableResult decisionResult = decisionService().evaluateDecisionTableByKey("tweetApproval", variables);
      assertThat(decisionResult.getFirstResult()).contains(entry("approved", true));
  }

  //Modelling of Happy Path here. Overwrite Scenarios
  @Before
  public void setupDefaultScenario() {
      init(processEngine);
  }

  @Test
  @Deployment(resources = {"tweetApproval.dmn", "exercise_1.bpmn"})
  public void testHappyPathWithScenario() {

      when(twitterScenario.waitsAtServiceTask("PublishTweetTask"))
        .thenReturn(task -> task.complete());

      Scenario.run(twitterScenario).startByKey("TwitterQAProcess", withVariables("email","norman.luering@camunda.com","content","test")).execute();
      verify(twitterScenario).hasFinished("TweetPublishedEndEvent");
  }

  @Test
  @Deployment(resources = {"tweetApproval.dmn", "exercise_1.bpmn"})
  public void testRejectedPathWithScenario() {


      when(twitterScenario.waitsAtServiceTask("DeleteTweetTask")).thenReturn((externalTask) -> {
            assertThat(externalTask().getTopicName()).isEqualTo("deleted");
            externalTask.complete();
        });

      Scenario.run(twitterScenario).startByKey("TwitterQAProcess", withVariables("email","cannot.tweet@camunda.com","content","test")).execute();
      verify(twitterScenario).hasFinished("TweetRejectedEndEvent");
  }
}