Writing and Running a PUnit Test
The example I have provided shows how you can do the following tasks in a PUnit test.

• Create an instance of a process
• Assign input arguments to a process instance
• Assert that the instance is running
• Get the current activity of a running process
• Get the value of an instance variable (only works for simple data types)
• Assert that a process instance arrives at a certain activity within a certain amount of time

You can do much more with the session object. But these are the activities I usually do in a Process test. The Fuego.Test.ProcessServiceSession has some similar methods to the PAPI ProcessServiceSession. But, the PUnit version is quite different. You don't have as much flexibility as do with PAPI.

But, you are able to interact with interactive activities. Here is how you do it. Right-click on the interactive activity you are including in your process test, select the "PUnit task" menu option.


Testing Interactive Activities

Since PUnit tests are automated, and there is no actual user interaction, you specify how the interactive activity changes the process instance (when you are running the PUnit test) in the PUnit task. So if the interactive's output parameter set an instance variable, you would set the same instance variable in the PUnit task method.

Next, in the PUnit test method, when you are sure the process instance is waiting at the interactive activity, use the session.activityExecute method to execute the PUnit task specified.

To run the test method, first start the ALBPM or OBPM 10g engine. Then right-click the method in the Catalog, and choose "Run Test". The "Test Results" pane will pop-up and you can watch the test execute.

The Test Results Pane

If you are using objects in your Catalog which have been introspected from jar files as input or output parameters of processes, you will need to modify Studio/Eclipse's classpath. The test runner executes the tests in Eclipse's Java environment. So, while writing the test code, there are no errors (Eclipse knows what is in the Catalog), and the engine runs fine (in another Tomcat Java environment which has the jar files deployed with the BPM project), the test runner will report ClassNotFound. This is pretty tricky, I solved it by modifying the file %BEA_HOME%\albpm6.0\studio\eclipse\configuration\config.ini and changed the osgi.frameworkClassPath value to include my custom jar files in Eclipse's classpath.

While this worked for me, occasionally I still received ClassNotFound errors. But these went away when I restarted ALBPM Studio.

Limitations of PUnit Tests
You can get the values of instance variables returned to the test method. However, this only works reliably for simple or native data types. Complex datatypes (business objects, and introspected objects) can be viewed as XML if they are serializable. Otherwise, their values can't be inspected in the test.
Testing processes which use subprocesses and Split/Join activites can be difficult. You can't get a subprocess' Id from the parent process. And targeting a specific thread in a Split/Join group can be difficult.

Those limitations aside, testing Processes with PUnit is a pretty useful feature. One of the more welcome features is the ability to change the PUnit test method and run it without having to stop the engine or redeploy the process.

Writing and Running CUnit Tests
As mentioned earlier CUnit tests can be used in the traditional fashion to test code written in Business Objects to insure they work as expected. You create and write CUnit tests in the same way as you do PUnit tests. You also have to start the names of CUnit test methods with the word "test".

CUnit tests can also be used to verify or proove that External Systems (Web Services or Databases, etc.) are returning the expected responses to your inputs. Or, they can be used to do ad-hoc testing of Business Object code.
The advantage of CUnit tests to PUnit tests is that you don't need to have an engine running or a process deployed to run them. But if you are using introspected jar's in the test code, you will need to change Eclipse's classpath as shown earlier.

Using a PAPI JUnit Java Test Environment
Sometimes you need to test your BPM project in a J2EE container because the process just does not behave the same way in Tomcat as it does in WebLogic Server. To do this, simply write JUnit test cases using PAPI. Doing this has some advantages and disadvantages to using the PUnit test cases.

• If your subprocess activity has the "Generate Events" option turned on, the PAPI JUnit test case can pick up a process' subprocess id and continue testing. You can't do this with PUnit tests.
• You can get the vales of instance variables of complex data types.
• PAPI JUnit test methods can not execute interactive activites in a process. PUnit tasks are not available ouside of ALBPM / OBPM Studio.

Once written PAPI JUnit tests can be run on both the J2EE engines as well as ALBPM / OBPM Studio engines.
You can download this example to get you started creating a PAPI JUnit test suite.

Most of us software developers are familiar with the venerable Model/View/Control (MVC) methodology which has greatly increased memory efficiency, performance, and maintainability in our projects. I have developed a similar methodolgy for developing BPM projects in OBPM / ALBPM which has proven to be successful.

Three Kinds of Business Objects

The BPM Component Catalog allows you to introspect many kinds of objects from disparate resources. While this is very convenient, don't get into the trap of using those objects as they are imported. This will usually get you using objects which consume much more memory than you need. It is better to create new objects which just accomplish what BPM needs to do, and have methods or helper objects to transfer the appropriate information between concerned objects.

Sample Business Model Object

If you start to segregating your object, you will end up having three kinds of objects: Business Model Objects, Process Flow Objects, and Process View Objects. I will explain what I mean below.

Separating the Object Into Useful Portions

Business Model Objects

These are usually the objects which are introspected into the Component Catalog. They are very detailed an complex. They probably have relationships with other objects. They represent the knowledge of a business concept, or at least how those concepts interact with the business' systems.

Business Model Objects are very useful for interacting with web services, databases, and other external systems. But for processes because of their memory requirements. And, they are cumbersome to use for user interfaces because the data is optimized for retrieval and storage, not for data entry or display to a human.

Process Flow Objects

The Process Flow Objects contain a subset of the information stored in the Business Model Objects. The idea is to only have information in these objects which the process flow will need for decisions and supporting the process flow.

Process View Objects

These objects also contain a subset of the Business Model Objects. The focus of the Process View Objects are supporting Screenflows or Presentations. The data and object structure of these objects is optimized for easy presentation of user interfaces.

Using Business Model Objects in the Process Flow

So if you take the bait, and use your Business Model Objects as instance variables in your process flows, here is what happens. First, there is a big splash as the object is filled in by your back-end systems. Information is shared between activities by putting in or changing data in the object's attributes. As the process goes through its life-cycle, the object grows in memory usage. And, the object is using memory for the full duration of the lifespan of the process.

Using Business Model Objects in the Process Flow

Using the Three Object Types Method in the Process Flow

Business Objects are used in automatic activities to provide data to the Process Flow and Process View objects. They are then unloaded from memory.The objects with the smallest footprint (the Process Flow objects) are in memory the longest.

Using the Three Object Types

Process View objects are loaded with data in order to support interactive activities. They are only in instance memory long enough to complete the interactive activity, and send the results to the other objects. Since these objects are optimized for the screenflows, their memory usage is reduced.

Object Type Relationships

Well That's Nice, But...

Yeah, sometimes you just need to keep large chunks of data around to avoid performance problems caused by excess chatter (from continually loading the Business Model Objects). This is when you would use "separated" instance variables. These are then stored in a database table and not in direct instance memory.

How to Segment Business Model Objects

First, Business Model Objects can have methods to load and save to database/webservice/etc. This keeps the complexity of the persistence method out of the process flows completely.

Segmenting the Objects

Next, Process Flow Objects can have methods for loading their information from the Business Model Objects.

Then, Process View Objects can have methods for loading and saving their information back to the appropriate objects.

Not as Simple as it Sounds
OBPM makes it seriously easy to implement Web Service integrations. Just introspect the WSDL into the catalog and then drag a method from the catalog to a code-block. The response is usually returned immediately in the typical HTTP request/response cycle. Plus, all of the objects involved are usually embedded in the WSDL so everybody knows what they are talking about.
With JMS, the BPM process has to listen to a JMS Queue with a Global Automatic activity and manually wait for a response using a Notification Wait activity for an asynchronous response. Also, if you are doing more than just simple text JMS messages, all the objects being used will need to be manually introspected into the catalog, and kept up to date with what the other side of the JMS conversation is using. The following diagram shows the differences.

The Message Router
You may be asking why you need two processes for this to work. Well, if you just have one JMS conversation going on, then you will only need one process. Something like the following diagram will certainly do the trick.

But, if you have several conversations going on with numerous processes, you won’t want to have a single JMS queue built for each conversation in each process. You will probably want to use just a few JMS queues and route messages to the processes based upon what is in the messages (such as by object type). Thus you will end up with something like the following message router process (MRP).

Note: I don’t like using the Process Notification activity to notify processes. If the process instance to be notified is not found, the instance of the MRP is aborted. If an error handler is present in the MRP, this can be avoided, but the engine still logs a Warning error in the log. Get enough of these, and it can really clutter up the log. I prefer to use the PBL Notification.Send method in an Automatic Activity. Then, you have more control over what happens in these scenarios.

Processing the Notification
A Correlation Set has to be created and initialized by the process receiving the notification from the message router process (MRP) before it receives the notification. This is so that the MRP can find the appropriate process instance by the unique business Id. The MRP does not need to know about the Correlation Set, it just needs to set the appropriate unique business Id argument before sending the notification.
The receiving process also needs to handle unexpected problems with the messaging conversation. Here are a couple of examples. First, to handle the case where the JMS sender never sends a response, an activity with a due transition needs to be present to time-out the conversation. Next, when the sender responds with a message that it couldn’t perform the desired action, a conditional path is created.
So our simple example from earlier now looks like this.

Whew! That’s a lot of infrastructure to build up just to replace a simple Web Service request/response. Yeah, JMS may be more efficient, but its implementation here is much more verbose.
Now that you have a better idea of how to do it, I have a few implementation patterns you may want to consider in implementing JMS in OBPM/ALBPM.

JMS Process Pattern 1: Interrupting Interactive Activities
This is a case where a process instance is waiting at an Interactive Activity, and it needs to move on to the next activity when it receives a JMS message. Essentially, the process flow is blocked by an Interactive instead of a Notification Wait activity. This pattern works well when you want the process instance to appear in the Workspace inbox even though it is actually waiting for a JMS notification. The user can then have the opportunity to interact with the process without having to search for it and use a Grab.

I like this pattern because it increases the visibility of the process instance in the Workspace. Plus, it gives the user more information and influence over the instance. The user can have their view set to sort by instance creation date, and easily see which instances have been stuck too long waiting on a notification. If we used Notification Wait’s to block the process, a custom view would need to be created to cause the instances to be visible.

A Correlation Set is initiated in the Begin activity, and used in the Notification Wait activity. The latter has the “Allows Interruptions” option turned on so that when the notification occurs, it will interrupt the running instance in a way similar to the error handling flows. In the automatic activity, the PBL sets the predefined variable “action” to SKIP. Thus, when the notification flow reaches the Compensation Activity, the process instance will skip the processing of the current activity (the interactive) and proceed on to the next activity down the unconditional path towards the “Finalize” activity. The Grab Activity is there so participants in a more administrative role can easily move the instance along the path should the notification never arrive.

JMS Process Pattern 2: Manually Moving a Process Instance
The “action=SKIP” strategy only works if the next activity in the process flow is where you want the instance after the notification arrives. What do you do if you need more control over where the process instance goes? That is the question that the following pattern answers.

The diagram of this pattern is exactly like the previous one, except for the addition is the “Exception Grab” activity. This is a From All/To All Grab. I call these “Exception Grab’s” because they are usually used as a method of last resort to fix a process instance that has gone down the wrong path.

In the notification flow, the Automatic Activity uses a round-about way to automatically execute the Exception Grab to send the instance to the activity of choice.

Because you can’t execute a grab while in a notification or error flow, a simple process is created to connect to the engine, find the process, and execute the grab.
All of the code and the processes are included in the sample project export that can be downloaded below. Also, this example (in the export) shows how to manually initiate and finalize the Correlation Set in PBL.

JMS Process Pattern 3: Handling Multiple Asynchronous JMS Responses
This pattern addresses the case where a single request can cause multiple JMS responses. And, these responses can arrive in any order. But the process must wait for all of the messages to be received and so something with the responses as they arrive.

To achieve this, a business object is created in the catalog to keep a record of the messages that have arrived. The business object is implemented as an instance variable. The flow is blocked by an Interactive Activity only if a message has not been received.
This example shows how to use activity.source to determine where in the process the instance was at when the notification arrives. It also shows how instance state can be preserved when multiple asynchronous events are occurring, and they can occur at any time of the life of the instance. Boolean flags are used in the business object instance to insure that the process instance only reacts once to a certain type of message.
Note: In the process export all four Automatic Activities utilize the same process method.

Process Project Export
All three of these patterns are included in the following Process Project Export. Also included is the “GrabAndRedirect” process and demonstrations on how to send a JMS message in PBL. Here is the download.

I had just finished playing with FWZipLib.dll wrapper around the Info Zip libraries. So, I quickly wrote this utility to scan a folder of jar's (which are just zip files anyway) for a class provided on the command line. It proved so useful that I still use it occasionally.

It is a simple C# console application. To use it, here is the syntax:

FindClass ClassNameToFind c:\SomeFolder\SomeJavaApp\lib

The utility will then list all of the jar files in the folder. Then, it will tell you when it finds the class file in one of the jar's.

However useful it may be, I never really updated it with any fancy features. There are other utilities which other jar-heads use for this feature. But if you like a simple, and free, utility to find those elusive classes, you can download it here.

The FWZipLib is a C++ DLL wrapper around the venerable Info Zip library for Windows. This makes this library accesible to .NET applications. It can do all of the standard operations on zip files: compression, decompression, listing of zip file contents, password protection, etc. Basically, just about anything the Info Zip library can do.

Hold On a Minute
There are a couple of things you must know before using this library. First, there are much better libraries out there for .NET. (Particularly the SharpZipLib.)
Second, I really don't think that it is all that thread-safe. (I haven't really tested it.) If you need it for small one-off utility programs, console or forms applications it will probably work fine.

Usage
To use it in your average C# program, just reference the FWZipLib.dll. Then, make sure you copy the Zip.dll and UnZip.dll files into your bin folder. These are the Info Zip libraries which actually do the work. The FWZipLib.dll provides the interface to the Info Zip dll's.

The Download
The download includes the source code and the compiled binary for the FWZipLib.dll. It also contains a VB.NET test client to show you how the syntax works.

Necessity being the mother of invention, I rolled out the TemplateCopy command-line utilty. What this fella does is seek out all presentation templates of a specific name, and/or with a certain HTML comment tag in the first line, and replace it with a text file provided on the command line. After replacing the presentation template, it can automatically publish the results.

This has been a useful utility. It really saved our bacon once. Then, it provided a convenient way to roll out changes to portlets and content based upon presentation templates.

If you are an extensive user of Publisher and have a similar problem, this tool may save you from getting carpal-tunnel syndrome from changing presentation templates in Publisher Explorer.

Here is the link to add this to your toolbox.

The difficulty is that the content administrator will eventually need to get aquainted with Publisher Explorer if they are really going to be effective. I have seen that this is a major turn-off to users and sometimes an impediment for user acceptance of Publihser as a tool they want to use.

The Publisher "Plus" Portlet Pack was created to target this problem. These portlet templates allow the community/content administrator to create portlets and place them on the community page without having to know anything about how Publisher is working. The editing and publishing of content is done in the portlet. If the user has Edit activity level rights on the portlet, a toolbar appears at the top allowing them to manage the content. The really great thing is that the content contributor can see and edit the content in the context in which it will ultimately be viewed.

Meet the Cast

Announcement Plus
The Announcement Plus porltet template is there for you if you just need to put some simple HTML content into a portlet. It has all the great features of the Announcment portlet: WYSIWYG editing, image uploading, etc. The plus is the fact that you can edit it on the portal page.
The following images show what it looks like in the portal when the user has only Read rights. The next image shows what it looks like when the user has Edit rights. Notice the toolbar across the top. The "Edit Portlet" link opens up the Publisher window, allowing the user to check out, edit, and publish the content.
Note: Since the portlet is designed to show just about any HTML content, I have filled these with Lorem Ipsum filler text.

Announcement Plus Portlet -- View Only

Announcement Plus Portlet -- Edit Enabled

News Plus
The News Plus portlet template, much like the old News portlet, is a container for some HTML content above a list of links to other HTML documents. It also sports an optional image which can float to the right of the document links.

Here are a couple of images to show how it might look in the portal. Again, notice the toolbar above the content when the user has Edit rights to the portlet. Also, each content item has an edit link next to them, allowing the content administrator to change the HTML file to which the portlet is linking.

News Plus Portlet -- View Only

News Plus Portlet -- Edit Enabled

At the bottom of the portlet is a section which only appears in Edit mode, when there are unpublished HTML documents. This allows the content administrator to polish the document before publishing it to the public.

Here are some of this portlet's features:

1. An optional block of HTML (or rich text) can appear at the top of the list of messages.
2. An optional image can be placed so that it floats to the right of the list of messages.
3. The editor can change the number of messages to display at a time in the portlet. If the number of messages exceeds the specified number, a “View All…” link appears.
4. An optional message abstract can be provided. (See the first message item in the images above.)
5. An optional search textbox and button can appear, letting the user search for a specific message in the list.
6. If a user creates a message item, but doesn’t publish it, it will not display in the normal list. In order to edit it, a list of “Unpublished Content Items” will appear below the normal list for users with EDIT privileges.
7. Changes to the message items will not appear to all the users unless the containing portlet is published as well as the message itself. To make this easier for the content editor, a “Publish” button is provided in the action bar.
8. The publish dates of the messages can also be displayed if the option is chosen. (Not shown.)

Links Plus Portlet
One of the most frequent portlet requests by customers has always been portlets where users can manage their links. I don't have enough fingers to count the many links portlets I have seen. Well, here is my version (or at least one of them).

This portlet has all the great features of the News Plus Portlet. That is because it is based on it. But, instead of links to Publisher-managed HTML links, the user can type (or paste) in the links they want. If used with the Get Portal Link portlet, the user can easily create links to interesting places in the portal.

Links Plus Portlet -- View Only

Links Plus Portlet -- Edit Enabled

In case I forget, here is the list of features for this portlet:

1. An optional block of HTML (or rich text) can appear at the top of the list of links. (Shown in the View Only image.)
2. An optional image can be placed so that it floats to the right of the list of links. (Shown in the Edit Enabled image).
3. The editor can change the number of links to display at a time in the portlet. If the number of links exceeds the specified number, a “View All…” link appears. (Shown in the Edit Enabled image)
4. An optional link description can be provided. (See the second link in the Edit Enabled image.)
5. An optional search textbox and button can appear, letting the user search for a specific link in the list.
6. If a user creates a link, but doesn’t publish it, it will not display in the normal list. In order to edit it, a list of “Unpublished Content Items” will appear below the normal list for users with EDIT privileges. (Shown in the Edit Enabled image)
7. Changes to the link items will not appear to all the users unless the containing portlet is published as well as the link itself. To make this easier for the content editor, a “Publish” button is provided in the action bar. (Shown in the Edit Enabled image)
8. The order of links can be set by changing the "Name" attribute of the link items. This value is not displayed in the portlet.

Image Links Plus Portlet
The fun continues with the Image Link Plus portlet template. Actually, I did have a bit of fun with this one.

I thought it would be neat to have the links from the Links Plus Portlet appear like the icons appear in the Tile View of the Microsoft Windows File Explorer or the Icon View of Apple's OS X Finder. At the time, I was playing around the the CSS float style. The result: the Image Links Plus portlet. It really doesn't have a great use case. I just thought it was cool.

The images show up from left to right, top to bottom. They float around the available space in the portlet as the user changes the width of the browser. The dimensions of each link can be specified by the content adminiatrator to help control how the links float around each other.

Image Links Plus Portlet -- View Only

Image Links Plus Portlet -- Edit Enabled

This portlet has all of the features of the Links Plus Portlet, from which it was derived.

The Adaptive Content Portlet Pair
I got bored one day watching my compiler messages roll past when I thought of this one. What if you had a News Plus portlet on one side of a portal page and another portlet on the other. When the user clicks on one of the content links in the News Plus portlet, instead of having the HTML content pop up in another window, wouldn't it be cool to have the content appear in the other portlet. Kind of like a master-detail relationship. Think of the cool things users could do with that!

So, I twisted Publisher's arm a bit, sprinkled a little JavaScript around, and practiced my favorite curse words. Finally, I got this baby to work.

There are two portlet templates you will need to get this to work: Adaptive Conetent Master (the modified News Plus portlet), and Adaptive Content Detail (the portlet where the content will be loaded). Here are some images for you to get the idea.

Adaptive Content Portlets, Initial Page Load -- View Only

Adaptive Content Portlets, Initial Page Load -- Edit Enabled

You will notice that, unlike the News Plus Portlet, the content items do not have edit links next to them. That is because, in the spirit of all of the Publisher Plus Portlets, you edit the target content in place, in the Adaptive Content Detail portlet.

Adaptive Content Portlets, Content Item Selected -- View Only

Adaptive Content Portlets, Content Item Selected -- Edit Enabled

If you like, you can have another portlet on the page use the Adaptive Content portlets' JavaScript to load content items into the Adaptive Content Detail portlet by content name. The following image shows this in action (sorta). You can see the HTML portlet at the bottom left of the image, the link with the outline around it has just been clicked. The content has just been loaded in the Adaptive Detail portlet.

Adaptive Content Portlets, HTML Access of Content Items

Here is the HTML code of the anchor tag shown in the image above.

  <a href="#" onclick="get_Content_Item_By_Name('Article1'); return(false);">viverra nec</a>

Seen Enough?
Working with Publisher can be quite the challenge. And, I don't know what the future holds for the dated product. But, if you are interested in using these portlets, you can download from here.

Note: These portlets require the fpw.useractivitylevel custom tag in order to determine user access rights to the portlets. If you don't like the portal modification, you can always replace this tag with the more traditional method, by editing all of the presentation templates.

Now, I'm not a big fan of the WCI native API. It's largely undocumented, a bit cumbersome, and it is usually one of the biggest problems portal administrators have to deal with when upgrading to a new version of the portal. But sometimes, you gotta do what you gotta do.

I needed a way to secure portions of HTML content. There are ways to do this with Adaptive Tags. The problem with the way that it was implemented is that you have to hard-code the arbitrary numbers the portal gives to the group and user objects. Which is fine, as long as you don't have to migrate content between portals like you have to do when moving from QA to UAT to Production.

The fpw.useractivitylevel tag was created to solve this problem. Any HTML content put within the beginning and ending of the tag is only sent to the browser if the user has the appropriate activity rights (Admin, Edit, Select, Read, or None). Thus, the portal or community administrator just needs to set the security levels they want on the portlet, page, or community. The portlet developer or content author does not need to know the ID numbers of who needs to get to the content, just what access levels they should have.

Syntax
Here is an example of how it looks in the wild.

<pt:fpw.useractivitylevel pt:scope="GADGET" pt:rettype="ENGLISH" pt:atleast="EDIT">
  Secure content goes here
</pt:fpw.useractivitylevel>

The pt:rettype attribute value can be either "ENGLISH" or "NUMERIC".

The pt:scope attribute value determines what object in the scope is used to restrict the content: "COMMUNITY", "PAGE", or "GADGET" (portlet).

The final attribute can be either pt:atleast (the usual) or pt:below depending upon which way you want restrict content, either from less to more secure, or from more secure to less secure. The value of this attribute can be either "ADMIN", "EDIT", "SELECT", "READ", or "NONE" if pt:rettype is "ENGLISH". Or, if you want to be more obscure, you can use the numeric ID's by setting the pt:rettype ot "NUMERIC": 15, 7, 3, 1, or 0.

Additional Details
In order to get some of the security details to the new tag, I also had to modify the MyPortal object.

Also, this tag was originally written for the v6.0 ALUI portal. When I updated it to the 10g version I noticed that it caused some problems with the new Dojo-based MyPages. Something about a casting problem.

The Link
If you like this idea, you too can have this tag in your portal. Get it here.