I am utilizing properties on class methods to good effect.

I would not use a classmethod only approach for normal development.

There is nothing stopping a community parallel UnitTest.Manager re-implementation that follows a ClassMethod pattern.

Some have reimplemented UnitTest.Manager:

1) Without Deleteing the test classes at end of run (With Run instead of DebugRun)

2) Not needed ^UnitTestRoot to be defined.

If for Interoperability productions it may also be appropriate to weigh up existing capabilities available for Production deployment. See: https://docs.intersystems.com/irisforhealth20232/csp/docbook/DocBook.UI....

It provides functionality for detecting implementation used by a production.

Have created idea for Production exports to generate IPM modules as well as the usual XML export deployment. https://ideas.intersystems.com/ideas/DPI-I-382

Would this make sense as an enhancement to System Default Settings?

So in System Default Settings input to a new "Environment Name" field instead of completing "Value" field?

Have created idea: https://ideas.intersystems.com/ideas/DPI-I-381

https://docs.intersystems.com/irisforhealth20232/csp/docbook/DocBook.UI....

An example idea for Grand Prix entry:
Demonstration of a "Language Interface" (chat interface) to replace the functionality of a traditional online shop ( HTML UI )

•   Use IRIS to hold a product catalogue (Images, Description, Cost, Stock)
•   Use IRIS to present the "Language Interface". Can support via Embedded Python
•   User Experience:
  •   Describe what you want instead of search
  •   Filter products based on preferences identified in conversation
  •   Automatically locate products via catalogue meta data from conversation content
•   CSP or other web Session for current Shopping basket (Item, Quantity, Total)
•   Persist and reuse preferences identified from previous shopping chats

May find related API wrapper on community useful:

Returning [ named ] output arguments as a result tuple.

Can also return value of %objlasterror

https://community.intersystems.com/post/tuples-ahead

Access to Multidimensional Properties:

https://community.intersystems.com/post/embedded-python-access-multidime...

Cloning a particular task based on persistent class implementing %ConstructClone.

Can be good to have distinct names

ZN "%SYS"
set taskToCopyId=1000
set source=##class(%SYSTEM.Task).%OpenId(taskToCopyId)
for ns="FTP","WSDL","X12" {set copy=source.%ConstructClone()  set copy.JobGUID=""  set copy.Name=source.Name_" "_ns  set copy.NameSpace=ns  write !,ns," result ",copy.%Save()}

Can see other properties might want to reset via OBJ.Dump

set taskToCopyId=1000
set source=##class(%SYSTEM.Task).%OpenId(taskToCopyId)
do $SYSTEM.OBJ.Dump(source)

Thanks for sharing answer.

Adding a snippet for %ZSTART in case fellow community person wished find / refer to later.

 #include %occStatus
  quit 0
SYSTEM() PUBLIC {
    Try {
    // Some test to determine whether to start or not
        if ##class(%File).Exists("c:\tmp\stop.txt") {
          Do INT^SHUTDOWN
        }  
    } Catch { }
quit 0
}

Great point Pietro. Experienced similar challenge for a global.

Between Cache 2010.2 and IRIS 2019.1 I needed to use ^%GOF and ^%GIF.

Also as global was mapped to different database, I needed to change from Namespace to Database Directory context for %GOF to export the data.

A thought about moving from *.xml source controlled files to *.CLS (UDL) file content with VSCode.

• The exported source content is different from existing in source control
• The export name is different and may be seen as an unrelated resource

A while back I had shared community application ompare

I mention as this utility allows the comparison of what is installed in a namespace, regardless if the external format was XML or UDL. Some may find useful to see the real differences between their own historic product releases and a current release. At least until have a few releases / baseline in their new source repository.

Have notice other community apps like xml-to-udl that might be appropriate for need.

In Routing Rule context, the newly projected function ExistsAny is applied.

The first argument is the LookupTable name from method signature.

An example expression:

1=(ExistsAny("AnemiaResults",Document.[OBX:5]))

It is common to need to run unit tests for other modules that have overlapping / breaking functionality.

This is where the value of loading and running multiple TestSuites comes into its own.

Hi Evgeny,

The global ^UnitTestRoot needs to be set to a real directory to satisfy the CORE UnitTest Runner.

As the first argument "Suite" is not specified, then no sub-directories are needed.

Set ^UnitTestRoot="\tmp\"

... may be sufficient for your purposes.

A handy way to call UnitTest Case method in a terminal

Do ##class(%UnitTest.Manager).DebugRunTestCase("", "[ClassName]", "", "[MethodName]")

Run all Test methods for a TestCase:

Do ##class(%UnitTest.Manager).DebugRunTestCase("", "[ClassName]", "", "")

Placing a "break" line within a method can be useful when iterating creating the test. See the variables. Run other code and then type "g"+ [Enter] to continue.

The instance gives context to current test run, when raising assertions and other functionality.

Hi Christine,

Please consider if the following snippet may be helpful.

Includes some common checks to prevent invalid lookup

Class Test.Fun Extends Ens.Rule.FunctionSet
{

ClassMethod ExistsAny(pTable As %String = "", pValue As %String = "", pDelimiter As %String = "<>") As %Boolean [ Final ]
{
  Quit:""=pTable 0
  Quit:""=pValue 0
  Quit:""=pDelimiter 0
  Set result=0
  // Use Length Function to count delimited fields. Always one or more
  Set len=$Length(pValue,pDelimiter)
  For i=1:1:len {
    Set key=$Piece(pValue,pDelimiter,i)
    // strip white space at front and end
    Set key=$ZSTRIP(key,"<>W")
    // Avoid empty string for key lookup
    Continue:""=key
    // make uppercase for case insensitive search
    Set key=$ZCVT(key,"U")
    If $Data(^Ens.LookupTable(pTable,key)) {
      Set result=1
      Quit
    }
  }
  Return result
}
} 

I approached in similar way.

Difference was to use the built in "$Piece" function on original string, instead of using intermediary lists.

Also using the dynamic property names.

   ClassMethod AsJSON(value = "")
{
set dyn=[]
set len=$L(value,"|")
if len>1 {
for i=1:2:len {
set q=$P(value,"|",i)
set a=$P(value,"|",i+1)
set item={}
set item.number="number "_(i\2+1)
set item.squad=q
set item.answer=[]
set answer1={}
set answer1.initialLetter=a
do item.answer.%Push(answer1)
do dyn.%Push(item)
}
}
quit dyn.%ToJSON()
}

Have used "%" variables to share context between a chain of sequentially executing classmethods on a CSP page.

This means enriching existing %request.Data variable, as it is already there and instrumented for Dump, or can use a different % variable name.