Integration Archives - Blog IT

Mocking APIs with MMock

Pedro David — Mon, 18 May 2020 15:18:24 +0000

There is a time during the development of a project when a developer needs to test the interaction with an external API service. Maybe he needs to get predefined responses to his API calls. In this case, the solution is not to use the original API, but instead to build a mock of said API.

There are many ways to mock http APIs, usually by writing a web server that listens to the same endpoints as the API being mocked. Although this can be simple enough to do on some programming languages, there is an even simpler way to achieve the same results without having to write a single line of code: By using MMock.

MMock is a fast and simple mock http/https server which allows the definition of responses with a simple configuration file. It also has some handy features that I am going to describe shortly.

In this article I am going to use MMock 2.7.9.

Install and Run MMock

There are two ways to install and run MMock:

1. As a docker container, either using the pre-built docker image directly or extending it in your own Dockerfile, and then starting the container by running the command:

docker run -v :/config -p 8082:8082 -p 8083:8083

2. By running MMock directly on your machine. You need Go 1.8 or higher installed, and the MMock module:

go get github.com/jmartin82/mmock/...
mmock -config-path

You should see something like this when running MMock:

The mock http server is accessible at http://localhost:8083/, https at https ://localhost:8084/, and a handy MMock console, where you can track configurations and API calls, is accessible at http://localhost:8082/.

Now, before you start sending requests to your mock API, firstly you need to configure MMock.

Configuration Options

To configure an endpoint on your mock API you must create a configuration file for MMock.

The configuration file can be written in .json or .yaml, and should be placed inside the specified in the MMock run command.

The following is an exhaustive list of all the options MMock recognizes:

description: A small description for the current configuration. This will show up in the MMock console and is useful if you have lots of configurations
request: This group of options informs MMock about what kind of requests to expect. All options, except for method, allow global matching with *. All options must match for this configuration to be triggered
- method: http method (GET, POST, PUT, etc). Multiple methods can be separated by |
- path: url endpoint/path, http://localhost/8083/
- body: request body
- queryStringParameters: array of url query string parameters, http://localhost/8083/endpoint?key=value
- headers: array of http request headers
- cookies: array of request cookies
- host: host from where the request should originate
response: This group of options specifies the response that MMock should return
- statusCode: http status code (200, 404, etc)
- body: response body
- headers: array of http response headers
- cookies: array of http response cookies
callback: This group of options informs MMock that it should perform a request to an external API (will be introduced in a future release)
- method: http method
- url: API url to call
- delay: delay before sending request
- timeout: time to wait for response
- headers: array of headers
- body: http body
control: This group of options specifies some mechanisms that control some extra behavior of MMock
- pripority: specifies a value that defines the priority of this configuration over others
- proxyBaseURL: url to where MMock should send the received request. MMock then returns the response back
- delay: how long MMock should wait before responding
- crazy: randomly returns an http 500 error or 200 OK
- scenario: This option allows MMock to retain some state
  - name: arbitrary scenario name
  - requiredState: the required state of the scenario for this configuration to take effect
  - newState: the new state of the scenario after this configuration takes effect
- webHookURL: url that will receive a webhook from MMock

The only really mandatory configuration options are the request.method and request.path, although a configuration file with just those two options does nothing.

Example Configurations

Now some examples of what I think are relevant configurations, starting with a simple one that expects a request to /hello and returns a response with http code 200:

description: hello
request:
  method: GET
  path: "/hello"
response:
  statusCode: 200
  body: Hello!

With a configuration file as simple as this we have an endpoint which will always return a 200 OK response, no matter the request’s http body, headers, or cookies!

Now an example of a configuration that expects some query string parameters:

request:
  method: GET
  path: "/hello"
  queryStringParameters:
    user:
      - *
response:
  statusCode: 200
  body: Hello {{request.query.user}}!

For this configuration to trigger, the mock API must be accessed with the user query parameter, like so: /hello?user=john. In this case the response will include the query parameter value! As you might have noticed, the curly braces in the body option define variables, and in this configuration that variable is the value defined in the user query parameter.

The same kind of configuration is applied to headers and cookies, although for cookies only one value can be defined per cookie.

A more complex example involving multiple configurations which define states based on the requests performed:

request:
  method: GET
  path: "/user/:name"
response:
  statusCode: 200
  headers:
    Content-Type:
    - application/json
  body: >
    {
      "name": "{{request.path.name}}",
      "email": "{{fake.EmailAddress}}",
      "address": {
        "street": "{{fake.StreetAddress}}",
        "city": "{{fake.City}}",
        "zipcode": "{{fake.Zip}}"
      }
    }
control:
  scenario:
    name: user
    requiredState:
    - created

request:
  method: POST
  path: "/user/:name"
response:
  statusCode: 202
control:
  scenario:
    name: user
    requiredState:
    - not_started
    - deleted
    newState: created

request:
  method: DELETE
  path: "/user/:name"
response:
  statusCode: 200
control:
  scenario:
    name: user
    requiredState:
    - created
    newState: deleted

These three configurations emulate the creation, reading and deletion of a user.

The first configuration handles requesting data on a user by performing a GET request to /scenario/ (notice the :name variable in the path option). It returns mock user information as json if the scenario is in the created state, otherwise returns a 404 http error code.

Next, by performing a POST request to the same endpoint the state of the scenario will be set to created, which will enable us the perform a GET request and return the user’s data.

Finally, by performing a DELETE request to the same endpoint the state will be set to deleted, which will, once again, cause the GET request to return a 404 http error code.

Variables and Fake Data

As you were able to see in the examples above, MMock defines some variables you can use, enclosed in curly braces, like so: {{variable}}.

Most of the request information can be accessed through variables in the response, such as the path, query parameters, cookies, body (respectively: request.path, request.query., request.cookie., request.body), and more.

You can also return the content of files or urls in your response with the variables file.contents() or http.contents().

Lastly, MMock defines some variables that return mock data, such as brands, colors, countries, days, names, ips, phones (respectively, fake.Brand, fake.Color, fake.Country, fake.Day, fake.FullName, fake.IPv4, fake.Phone), and much more!

Conclusion

MMock can be an easy way to define simple mock APIs. The configuration options allows a wide range of behaviors which target the more usual API testing scenarios.

The project is under active development, so expect changes and fixes once in a while!

The post Mocking APIs with MMock appeared first on Blog IT.

[FIX] BizTalk Server 2010, 2013, 2013 R2 & 2016 errors “Class not registered (WinMgmt)” or “Access denied”

Gustavo Brito — Thu, 26 Jul 2018 10:41:24 +0000

Hi folks,

Due to Microsoft .NET Framework Security Updates, some BizTalk Server installations may be affected. Access denied or Class not registered errors.

BizTalk engine will still process messages, including sending and receiving them.

The symptoms:

You can’t see, stop or start host instances
You can’t refresh applications
Gives access denied or Class not registered errors while trying to load some panels inside BizTalk Server Administration Console
Random errors in BizTalk Server Administration Console while browsing
Other weird issues while deploying applications via Deployment Framework for BizTalk (BTDF)

.NET Framework (4.6.2) has received some security updates on 20th July 2018. These updates refresh some assemblies that are in use by BizTalk Server! Microsoft states that a fix is coming mid July 2018, but, at this moment, I’m not seeing these “fixes” in my machine…

The actual fix;

You need to uninstall ALL your .NET Framework updates for version 4.6.2 that were installed after 19th of July 2018! Follow these simple steps to uninstall them (if you don’t know how to do it):

Open Control Panel
Select Program and Features
On the left pane, select “View installed updates”
Uninstall every update that targets .NET Framework 4.6.X that were installed AFTER 19th July 2018

IMPORTANT NOTE: Uninstalling some of them may require a reboot. DO NOT REBOOT UNTILL ALL UPDATES ARE UNINSTALLED!

Below are some updates that were identified by users as source of their problems:

BizTalk Server 2013 R2: KB4338600, KB4338601
BizTalk Server 2010: KB4338602
Other versions: KB4338600, KB4338605, KB4338613, KB4338814, KB4338424, KB4338419

The one that was causing my BizTalk Server Administration Console to fail was KB4338606. As you can see, this update isn’t listed above. Those updates were identified by other users, they may not, by any means, be the origin of your problems. This is why I prefer to uninstall them all! Remember, your mileage my vary.

If you have any questions or if you need help to figure this out, feel free to post a comment! I’ll try my best to help you out!

The post [FIX] BizTalk Server 2010, 2013, 2013 R2 & 2016 errors “Class not registered (WinMgmt)” or “Access denied” appeared first on Blog IT.

BizTalk Server – HL7 Error: Failure executing BTAHL72XSendPipeline “Body schema is missing”

Tiago Oliveira — Sun, 22 Oct 2017 21:17:20 +0000

Recently I had a requirement to generate an HL7 ORM to send to Oracle.
To fulfill the requirements, an HL7 message must be generated inline inside an orchestration.
The ExecuteReceivePipeline method must be used in orchestration, to execute the BTAHL72XSendPipeline pipeline with the HL7 multipart message to finally generate the message in HL7 format.

All HL7 must be multipart messages consisting of three segments:

Body segment – The HL7 message (marked as message body part)
MSH segment – The HL7 header
Z Segment – HL7 custom segment

To generate the ORM HL7 message, the BTAHL72XSendPipeline requires that the “message type” property be promoted, otherwise the error “Body schema is missing” will be thrown.
This property cannot be directly set, because is a reserved property used by BizTalk, the only way is to copy from other message.
If your orchestration receives the same HL7 message type, it’s easy to fix this issue, just set the multipart properties from the inbound message using the “(*)” syntax. In this way, the “message type” property will be copied.
HL7MultipartMessage(*)=InputMsgForHl7BodyPart(*);

There are several posts with this fix like https://blogs.msdn.microsoft.com/biztalknotes/2013/03/06/biztalk-hl7-error-failure-executing-btahl72xsendpipeline-error-details-body-schema-is-missing/ and https://social.technet.microsoft.com/wiki/contents/articles/16181.how-to-execute-btahl72xsendpipeline-in-an-orchestration.aspx

If you do not have an incoming HL7 message, the solution is a little bit tricky.

Create an BizTalk ORM message (you can use other HL7 message type or versions depending of the business requirements);
Force the “message type” promotion executing the XmlReceive pipeline (inline in orchestration);
Set the message created in1) to the multipart BodySegments segment;
Copy the ORM properties to the multipart message ( HL7MultipartMessage(*)=ORMMessage(*) )

Hope this helps!

The post BizTalk Server – HL7 Error: Failure executing BTAHL72XSendPipeline “Body schema is missing” appeared first on Blog IT.

BizTalk Server HL7 – Strange break lines in MSH segment

Tiago Oliveira — Sun, 01 Oct 2017 20:35:17 +0000

If you create an HL7 MSH segment with XmlDocument, you can get a strange break line in all empty values, like in the following image.

The HL7 message will also be created with the same break line, generating an invalid HL7 message.

It’s easy to deal with it, just set PreserveWhitespace property in XmlDocument with “true”, before assigning it to the HL7 MSHSegment.

…
xmlDocument.PreserveWhitespace = true;
hl7msg.MSHSegment = xmlDocument;

You can get more info in https://msdn.microsoft.com/en-us/library/system.xml.xmldocument.preservewhitespace(v=vs.110).aspx.

The post BizTalk Server HL7 – Strange break lines in MSH segment appeared first on Blog IT.

How to fix BizTalk Server Administration Exception 0xC00CE557: Could not enlist Send Port

Gustavo Brito — Fri, 29 Sep 2017 17:07:51 +0000

With the need to deploy all port bindings from Visual Studio straight to BizTalk Server, I did export bindings on BizTalk Server Administration. With this, I can merge new ports that were configured manually to my Visual Studio BZ Project, so they can be deployed automatically. Just when I thought that all was well, a binding import error appeared, and some ports could not be enlisted and started.

Pic1. Exception: “Could not enlist Send Port – HRESULT: 0xC00CE557”

So, after some debugging, me and my teammate noticed an issue with some port filters inside a WCF Custom Send Port in the bindings XML, originally exported by BizTalk. Time to check the XML now!

Here’s how you can trace errors in XML:

Open exported ports binding XML file:

Pic2. Origin of the exception selected

Notice this property, “Filter”. It has break lines and white spaces. BizTalk refuses to import bindings like this, and generates an exception. Worst part is that this exception is generic, and meaningless.

To fix this, you must remove all white spaces and all break lines inside this field. This problem appears because these filters have an “AND” relationship between them, and BizTalk can’t understand those mathematical relationships with all these white spaces and break lines among them.

The final and fixed XML property should look like this:

all lines here without spaces or break lines

If you run into some exceptions importing port bindings, you should analyze the bindings file and look for a XML property with spaces and break lines. Re-arrange and you should be OK importing bindings and enlisting ports now!

The post How to fix BizTalk Server Administration Exception 0xC00CE557: Could not enlist Send Port appeared first on Blog IT.

BTDF – How to config BRE policies or vocabularies

Tiago Oliveira — Mon, 03 Jul 2017 22:49:26 +0000

Greetings to all BizTalk programmers 🙂

There’s not much information how to properly add a BRE rule in a BTDF deployment script.
It’s very easy to put it to work, but not so easy to get it there.

Just follow the below instructions :

Create the rule in Business Rule Composer.
Use the Rules Engine Deployment Wizard to export the created policy or vocabulary xml.
Put the exported policy or vocabulary xml in a VS project folder (I advise to put in Deployment/BRE/Policies folder).
Edit btdfproj file (if you dont’t know how to set this file, check codeplex BTDF site https://biztalkdeployment.codeplex.com).
Set “IncludeVocabAndRules” element with the value “true”.
Add the following elements (set the policy or vocabulary xml name and location).
The BRE rules are always updated after MSI or VS deploy by executing the options “Deploy BizTalk solution” or “Deploy Rules or Vocabularies”.

This configuration also works with environment settings variables (${variablename}), allowing us for example to set different policy data in quality and production environments.

The post BTDF – How to config BRE policies or vocabularies appeared first on Blog IT.

BTDF – Generate specific environment binding

Tiago Oliveira — Tue, 21 Feb 2017 22:59:38 +0000

BizTalk Deployment Framework (BTDF) is known as the best way to perform BizTalk artifacts installation.
It’s also the only way (I know) to create an automatic BizTalk deployment.

If you don’t know what is BTDF, go to https://biztalkdeployment.codeplex.com.

This Framework allow us to create an MSI deployment package directly from Visual Studio or Command Line.
It also has a great feature that allow us to maintain only one binding file concerning all environments.
That binding template files are replaced for the correct environment data in the MSI generation.
The specific environment data is configured in a XML file that can be opened in Excel.

Sometimes there are releases that only have binding changes, and you want to use the best practice of always use BTDF generated data in your deployments.
So… how can you deal with this in BTDF.!! The VS menu does not have an option to generate environment bindings.

The BTDF installation give us a tool called xmlpreprocess, which is used in the MSI generation by the BTDF engine.
Xmlpreprocess tool allow us to merge a specific environment configuration with the binding template (normally named master binding), resulting in the transformed deployment binding.

It’s very easy to use.

Open a Command Line Prompt
Navigate to the BTDF install folder “..\Framework\DeployTools” (normally C:\Program Files (x86)\Deployment Framework for BizTalk 5.6\Framework\DeployTools)
Execute xmlpreprocess.exe /v /c /noDirectives /i:”PORT_BINDINGS_MASTER_XML_PATH” /o:” OUTPUT_BINDING_FILE_PATH” /d:CurDir=”MAIN_SOLUTION_FOLDER” /s:”ENVIRONMENT_TO_GENERATE_BINDING_CONFIG_XML”

For example

xmlpreprocess.exe /v /c /noDirectives /i:”C:\Projects\MyProject\Deployment\PortBindingsMaster.xml” /o:”C:\Projects\MyProject\GeneratedBindings\OutputBinding.xml” /d:CurDir=”C:\Projects\MyProject” /s:”C:\Projects\MyProject\Deployment\EnvironmentSettings\Exported_ProdSettings.xml”

The generated environment (Local, QA, PRD, …) is defined in xml file path after the “/s” parameter.

Hope this helps.

The post BTDF – Generate specific environment binding appeared first on Blog IT.

BizTalk News – Issue #15

Pedro Vala — Thu, 21 May 2015 15:06:39 +0000

BizTalk Server Single Sign On – Save config data in SSO

Tiago Oliveira — Mon, 05 Jan 2015 23:14:53 +0000

This is my last post about using SSO on Biztalk Server. In this post I will show how to set and retrieve configuration data from SSO.

To configure and set configuration data, Microsoft has an MMC Snap-In called “SSO Configuration Application”, that allow us to create and manipulate applications and their properties (http://www.microsoft.com/en-us/download/details.aspx?id=14524).

From the community there are several tools to set SSO configuration. The most well know was created by Richard Seroter in 2007 that allow us to manipulate previously created properties in an easy way (http://seroter.wordpress.com/2007/09/21/biztalk-sso-configuration-data-storage-tool/). There are also some Richard Seroter tool improvements, like a version from Mark Burch in http://biztorque.net/archive/2010/06/07/74.aspx, that allow us to create new SSO properties.

BizTalk Deployment Framework also include an SSO module, that use a different approach of using the Excel to set SSO config data in each environment (http://biztalkdeployment.codeplex.com/).

To get configuration from SSO by code, you can use “SSOConfigHelper.cs” included in Microsoft BizTalk Server 2006 SDK, but still working with the latest Biztalk server versions (http://www.getcodesamples.com/src/2B2085E1/C4A921B1).
Just get the code and include “Microsoft.BizTalk.Interop.SSOClient.dll” in SSO install folder (for example C:\Program Files\Common Files\Enterprise Single Sign-On\Interop1.1\Microsoft.BizTalk.Interop.SSOClient.dll) and call the read method, setting the previous create application and property name.

Hope that 4 posts about SSO will help you to use SSO more frequently in BizTalk programming.

The post BizTalk Server Single Sign On – Save config data in SSO appeared first on Blog IT.

BizTalk News – SPECIAL – Integrate 2014

Pedro Vala — Mon, 15 Dec 2014 20:00:32 +0000

It seems a lot happened at Integrate 2014!

I’ve been reading all the stuff being written and it’s clear: the Microservices architecture has brought a big wave of surprise and enthusiasm around the BizTalk community! I leave you with some links and quotes I found relevant about the topic.

Edit: integrate videos available here

Integrate 2014

“Simply sit back, relax and watch this space for next few months!! there are tons of things happing, all good for people coming from Microsoft integration background” – Saravana Kumar

Integrate 2014 – RECAP

“Integration is no longer a vertical solution, it’s core to the application platform” – Kent Weare

Microsoft making big bets on Microservices

Integrate 2014 – Final Thoughts

“Microservices is not the name of the product, it’s a way you can build Stuff”

“BizTalk Services Isn’t Going Away, It’s Being Aligned to a Microservices Architecture”

“It’s a Good Day To Be a BizTalk Dev”

Integration and Microservices

“I cannot resist the temptation to call this new world ‘microPaaS’, or µPaaS” – Charles Young

BizTalk Microservices, Integrate 2014 and all my thoughts

“I’m pretty sure that what Power BI covers will replace our Business Activity Monitoring” – Nino Crudele

BizTalk Server, Microservices & APIs

Integrate 2014: Thoughts on the Announcement of the BizTalk Microservices Platform

“My immediate reaction was: this is Docker!” – James Corbould

Docker and Microsoft Partner to Drive Adoption of Distributed Applications to Every Enterprise Operating System and Cloud

“Microsoft and Docker share a common vision that multi-container applications should be assembled using both Dockerized Windows and Dockerized Linux components.”