camunda-workflow 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba961748beb590604ec47e0044a1ce7fa50f97d45bec52652a0e528011e4b2f3
-  data.tar.gz: 3886388d63f770a0fa49686489cbb5a82e3884df697d52cbb9c28582ac5dd867
+  metadata.gz: 58f9e45eda5edf72f257ab51baba32f2220b0827a288d7a8b2ab273ff2835738
+  data.tar.gz: db225b2cda8437c4bec69cf70f351037174c35bef5a0dbf57155162e813ff996
 SHA512:
-  metadata.gz: fc768ad2478ce728101e69d6c891e53e0045a0ea266a0c2d87d87109f0692cc9d7b3c554f4048c261d96d06e23c3c4f2b66a1054ceeb8f8804bcf3de1748bc05
-  data.tar.gz: de9541842d8c4158a7bf7553a527ffd25a67fdd7dfb6d1b1da8fa5fe713cb58f01c41f0f2dc1d91984b903aae95d77c91b98ea1120661fcb2dd1d37109ec2420
+  metadata.gz: 184e3cca0f5ac05638470045b50aa053a7f31ff36be976e8ed429d5bdd6b4270643e8b2d79d38fb448f8d256ce5d6e7f8c9b303e12451c43e05609ac174e2344
+  data.tar.gz: 73b2bb72fa227bf85cd9fe5f9d54e3f61040b9760d0157d43ea90530de12fb4856b51aa7869fd45aeffb13cdfa84b2fc509b803a255af2352edc6ca47c25f72f

data/README.md

@@ -5,7 +5,7 @@
 
 ## An opinionated interface to Camunda for Ruby/Rails apps
 
-[Her](https://github.com/remiprev/her) is used to communicate with the [Camunda REST API](https://docs.camunda.org/manual/latest/reference/rest/). 
+[Her](https://github.com/remiprev/her) is used to communicate with the [Camunda REST API](https://docs.camunda.org/manual/latest/reference/rest/) with a Ruby class corresponding to a Camunda external task.  
 
 ### Add to your Gemfile
 ```ruby
@@ -13,9 +13,16 @@
 ```
 
 ## Camunda Integration with Ruby
-The process definitions key becomes the module name of your implementation classes and must be set to the name of a ruby style constant (screenshot example provided below). This same process definition key should be set as the topic name for external tasks. Tasks are pulled and fetched and locked and then run. We expect classes (ActiveJob) to implement each external task.
+The process definitions key becomes the module name of your implementation classes and must be set to the name of a ruby style constant. 
     
-![image](https://www.evernote.com/l/Ajnoawx6CYhKha7OXUPkyeo6CjrxvSoTgOUB/image.png)
+![image](https://user-images.githubusercontent.com/498234/70742441-899ecf00-1ceb-11ea-9eb8-42dbb08dbd2d.png)
+
+
+An external task is created with a Ruby class name for the id. And the process definition key should be set as the topic name. 
+
+![image](https://user-images.githubusercontent.com/498234/70742635-fd40dc00-1ceb-11ea-8518-0fa5f6ea8028.png)
+
+Tasks are pulled and fetched and locked and then run. We expect classes (ActiveJob) to implement each external task.
 
 ### Integration with your worker classes
 
@@ -64,7 +71,36 @@ allows one to have some tasks be handled outside the Rails app. It confirms that
 
 #### Starting the Camunda server for development
 
-Start the application: `mvn spring-boot:run`
+[Java 7](https://www.java.com/en/) and [Apache Maven](https://maven.apache.org/install.html) are requirements to run 
+[Spring](https://docs.spring.io/spring-boot/docs/1.5.21.RELEASE/reference/html/getting-started-system-requirements.html). 
+Make sure all requirements for Spring are satisfied before starting Camunda engine via spring boot.
+
+Start the application: 
+```bash
+ cd bpmn/java_app
+```
+```bash 
+mvn spring-boot:run
+```
+The following Rake commands are available to maintain the spring boot server. 
+
+```Bash
+# Install the spring-boot app dependencies. 
+rake camunda:install
+```
+We suggest (not required) running the install command before running the spring boot server for the first time or if the pom.xml file is updated. The 
+install cleans up artifacts created by prior builds and installs the package dependencies into the local repository.
+
+```bash
+# Start the Camunda spring boot app
+rake camunda:run
+```
+
+```bash
+# Runs spring boot test suite
+rake camunda:test
+```
+ 
 
 Camunda-workflow defaults to an in-memory, h2 database engine. If you rather use a Postgres database engine, comment out the 
 h2 database engine settings in the `pom.xml` file located in `bpmn/java_app`. Default settings for using Postgres are available in the `pom.xml` file. 
@@ -110,7 +146,10 @@ The jar is in `target/camunda-bpm-springboot.jar`
 It will fail to start. Create a postgres database as a service in PCF and bind it to the application. The Springboot application is configured for Postgres and will then be able to start.
 
 #### Running java unit tests
-`mvn clean test`
+```bash
+# Run in bpmn/java_app directory
+mvn clean test
+```
 
 ## Usage
 ### Deploying a model

data/lib/camunda/workflow/version.rb

@@ -1,5 +1,5 @@
 module Camunda
   module Workflow
-    VERSION = '0.1.4'.freeze
+    VERSION = '0.1.5'.freeze
   end
 end

data/lib/generators/camunda/spring_boot/spring_boot_generator.rb

@@ -7,23 +7,33 @@ module Camunda
       source_root File.expand_path('templates', __dir__)
       class_option :app_path, type: :string, default: 'bpmn/java_app'
       class_option :diagram_path, type: :string, default: 'bpmn/diagrams'
-      # Copys all spring boot files into a rails application and provides a Camunda engine for testing.
+
+      # Links resources to a top level diagrams folder
+      def link_resources_folder
+        create_link File.join(bpmn_app_path, 'src/main/resources/'), File.join('../../../diagrams')
+      end
+
+      # Copies a sample bpmn file to help demonstrate the usage for camunda-workflow
+      def copy_sample_bpmn
+        copy_file 'sample.bpmn', File.join(diagram_path, 'sample.bpmn'), ''
+        copy_file 'ProcessScenarioTest.java', File.join(bpmn_app_path, 'src/test/java/unittest/ProcessScenarioTest.java')
+      end
+
+      # Copies all spring boot files into a rails application and provides a Camunda engine for testing.
       def copy_java_app_files
         copy_file 'pom.xml', File.join(bpmn_app_path, 'pom.xml')
         copy_file 'camunda.cfg.xml', File.join(bpmn_app_path, 'src/test/resources/camunda.cfg.xml')
+        copy_file 'logback.xml', File.join(bpmn_app_path, 'src/main/resources/logback.xml')
         copy_file 'application.properties', File.join(bpmn_app_path, 'src/main/resources/application.properties')
-        copy_file 'ProcessScenarioTest.java', File.join(bpmn_app_path, 'src/test/java/unittest/ProcessScenarioTest.java')
         copy_file 'Camunda.java', File.join(bpmn_app_path, 'src/main/java/camunda/Camunda.java')
-      end
-
-      # Copys a sample bpmn file to help demonstrate the usage for camunda-workflow
-      def link_resources_folder
-        copy_file 'sample.bpmn', File.join(diagram_path, 'sample.bpmn'), ''
+        copy_file 'camunda.rake', 'lib/tasks/camunda.rake'
       end
 
       # Add spring boot files to .gitignore
       def add_to_ignores
-        %w[.gitignore .cfignore].each do |file|
+        ignores = %w[.gitignore]
+        ignores << '.cfignore' if File.exist?('.cfignore')
+        ignores.each do |file|
           append_to_file file do
             "\n# BPMN Java app\n" +
               File.join(bpmn_app_path, 'target') +

data/lib/generators/camunda/spring_boot/templates/ProcessScenarioTest.java

@@ -1,11 +1,20 @@
-package example;
+/*
+* Process Scenario Test is a working example on how test bpmn files using
+* camunda-bpm-assert-scenario. It uses the sample.bpmn file supplied with
+* the generator and test the processes.
+*/
+
+package camunda;
 
-import org.apache.ibatis.logging.LogFactory;
-import org.camunda.bpm.engine.ProcessEngine;
 import org.camunda.bpm.engine.test.Deployment;
 import org.camunda.bpm.engine.test.ProcessEngineRule;
+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.spring.boot.starter.test.helper.StandaloneInMemoryTestConfiguration;
+import org.camunda.bpm.scenario.Scenario;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
+import org.springframework.test.context.junit4.SpringRunner;
 import org.junit.Before;
 import org.junit.ClassRule;
 import org.junit.Rule;
@@ -13,73 +22,50 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.context.SpringBootTest;
-import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
-import org.springframework.test.context.junit4.SpringRunner;
-import org.camunda.bpm.extension.process_test_coverage.junit.rules.TestCoverageProcessEngineRuleBuilder;
 
-import javax.annotation.PostConstruct;
-
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
+import java.util.Map;
 
-import static org.junit.Assert.*;
-import static org.assertj.core.api.Assertions.*;
 import static org.camunda.bpm.engine.test.assertions.ProcessEngineTests.*;
+import static org.mockito.Mockito.*;
 
-/**
- * Test case starting an in-memory database-backed Process Engine.
- */
-@RunWith(SpringRunner.class)
+@Deployment(resources = {
+  "sample.bpmn"
+})
+// Disabled SpringRunner for test until a graceful delayed solution for shutting down h2:mem database is in place.
+// Test are run in multi processes so using DB_CLOSE_DELAY=-1 doesn't work.
+//@RunWith(SpringRunner.class)
 @SpringBootTest(webEnvironment = WebEnvironment.NONE)
 public class ProcessScenarioTest {
+  @Rule
+  @ClassRule
+  public static ProcessEngineRule rule =
+      TestCoverageProcessEngineRuleBuilder.create()
+        .withDetailedCoverageLogging().build();
 
-    private static final String PROCESS_DEFINITION_KEY = "timer";
-
-    static {
-        LogFactory.useSlf4jLogging(); // MyBatis
-    }
-
-    @Autowired
-    ProcessEngine processEngine;
+  // Mock all waitstates in main process and call activity with a scenario
+  @Mock private ProcessScenario camundaWorkflow;
+  private Map<String, Object> variables;
 
-    @Rule
-    @ClassRule
-    public static ProcessEngineRule rule;
 
-    @Before
-    public void setup() {
-        MockitoAnnotations.initMocks(this);
-    }
+  @Before
+    public void setupDefaultScenario() {
+      // Define scenarios by using camunda-bpm-assert-scenario:
+      MockitoAnnotations.initMocks(this);
 
-    @Mock
-    private ProcessScenario process;
+      when(camundaWorkflow.waitsAtUserTask("UserTask")).thenReturn((task) -> {
+        task.complete(withVariables("foo", "bar"));
+      });
 
-    @PostConstruct
-    void initRule() {
-        rule = TestCoverageProcessEngineRuleBuilder.create(processEngine).build();
+      when(camundaWorkflow.waitsAtServiceTask("DoSomething")).thenReturn((task) -> {
+        task.complete(withVariables("approve", true));
+      });
     }
 
     @Test
-    public void testHappyPath() {
-        // Define scenarios by using camunda-bpm-assert-scenario:
-
-        //ExecutableRunner starter = Scenario.run(myProcess) //
-        //    .startByKey(PROCESS_DEFINITION_KEY);
-
-        // when(myProcess.waitsAtReceiveTask(anyString())).thenReturn((messageSubscription) -> {
-        //  messageSubscription.receive();
-        // });
-        // when(myProcess.waitsAtUserTask(anyString())).thenReturn((task) -> {
-        //  task.complete();
-        // });
-
+      public void testHappyPath(){
+        //ExecutableRunner starter = Scenario.run(myProcess)
         // OK - everything prepared - let's go and execute the scenario
-        //Scenario scenario = starter.execute();
-
-        // now you can do some assertions
-        //verify(myProcess).hasFinished("EndEvent");
-    }
-
-}
+        Scenario.run(camundaWorkflow).startByKey("CamundaWorkflow").execute();
+        verify(camundaWorkflow).hasFinished("EndEventProcessEnded");
+      }
+}

data/lib/generators/camunda/spring_boot/templates/application.properties

@@ -1,7 +1,7 @@
 #spring.datasource.url=jdbc:h2:./camunda-db;DB_CLOSE_ON_EXIT=false
 
 
-
+#DB_CLOSE_ON_EXIT is set to false to prevent the database from shutting down before test are complete.
 spring.datasource.url=jdbc:h2:mem:camunda
 spring.datasource.username=sa
 spring.datasource.password=sa

data/lib/generators/camunda/spring_boot/templates/camunda.rake

@@ -0,0 +1,25 @@
+# Runs Camunda spring-boot commands using rake.
+
+task default: %w[run]
+
+namespace :camunda do
+  # Path for the spring boot application.
+  mvn_path = 'bpmn/java_app'
+
+  # Starts the camunda engine e.g. mvn spring-boot:run.
+  desc 'Starts the Camunda spring-boot application.'
+  task :run do
+    system('mvn spring-boot:run', chdir: mvn_path)
+  end
+
+  # Runs spring boot test suite e.g. mvn test.
+  desc 'Runs test suite for Camunda spring-boot application'
+  task :test do
+    system('mvn test', chdir: mvn_path)
+  end
+  # Installs the spring-boot app dependencies mvn clean install.
+  desc 'Installs spring-boot dependencies for Camunda spring-boot app.'
+  task :install do
+    system('mvn clean install -DskipTests=true', chdir: mvn_path)
+  end
+end

data/lib/generators/camunda/spring_boot/templates/logback.xml

@@ -0,0 +1,22 @@
+<configuration>
+
+  <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+    <!-- encoders are assigned the type
+         ch.qos.logback.classic.encoder.PatternLayoutEncoder by default -->
+    <encoder>
+      <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
+    </encoder>
+  </appender>
+
+  <logger name="org.camunda.bpm.scenario" level="debug" />
+  <logger name="org.camunda.bpm.engine.cmd" level="warn" />
+  <logger name="org.camunda.bpm.engine.cfg" level="warn" />
+  <logger name="org.camunda.bpm.engine.test" level="warn" />
+  <logger name="org.camunda.bpm.engine.bpmn.behavior" level="warn" />
+  <logger name="org.camunda.bpm.engine.cmmn.behavior" level="warn" />
+
+  <root level="warn">
+    <appender-ref ref="STDOUT" />
+  </root>
+
+</configuration>

data/lib/generators/camunda/spring_boot/templates/pom.xml

@@ -20,7 +20,7 @@
     and EE repository below
     -->
     <camundaSpringBoot.version>3.3.1</camundaSpringBoot.version>
-    <springBoot.version>2.1.5.RELEASE</springBoot.version>
+    <springBoot.version>2.2.1.RELEASE</springBoot.version>
 
     <maven.compiler.source>1.8</maven.compiler.source>
     <maven.compiler.target>1.8</maven.compiler.target>
@@ -125,6 +125,12 @@
       <artifactId>jul-to-slf4j</artifactId>
       <scope>test</scope>
     </dependency>
+    <!-- Logback logging for better camunda-bpm-assert-scenario tests -->
+    <dependency>
+      <groupId>ch.qos.logback</groupId>
+      <artifactId>logback-classic</artifactId>
+      <version>1.2.3</version>
+    </dependency>
 
     <!-- Add your own dependencies here, if in compile scope, they are added to the jar -->
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: camunda-workflow
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Ankur Sethi
@@ -179,6 +179,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 5.0.0
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.20
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.20
 description: Integrate Camunda with Ruby via its REST api by expecting a Ruby class
   for each external task.
 email: []
@@ -219,6 +233,8 @@ files:
 - lib/generators/camunda/spring_boot/templates/ProcessScenarioTest.java
 - lib/generators/camunda/spring_boot/templates/application.properties
 - lib/generators/camunda/spring_boot/templates/camunda.cfg.xml
+- lib/generators/camunda/spring_boot/templates/camunda.rake
+- lib/generators/camunda/spring_boot/templates/logback.xml
 - lib/generators/camunda/spring_boot/templates/pom.xml
 - lib/generators/camunda/spring_boot/templates/sample.bpmn
 homepage: https://github.com/amalagaura/camunda-workflow