retest | Testprogram for libre and librem | SOAP library

You cannot use import firebase from "firebase/app"; inside a script tag in an HTML page.

Instead you should import those SDKs though their own script tags, as you've already done for

A contract test asks "are these services able to communicate with each other". This question is absolutely valuable for message queues.

Is it safe to deploy a new version of your consumer? It depends on whether the producer is able to read and understand the messages the provider is sending. Contract testing improves your confidence that the consumer and provider are able to speak to each other.

You could argue that contract testing is more important with message queues, because (depending on the design and how long messages live in queues/whether they are replayed), you might be consuming messages that were produced by several different versions of the producer.

Even if the consumer and provider are in the same deployment unit (eg, a single microservice), then you're likely to be consuming messages from the previous version of the provider immediately after a deployment happens.

Speaking theoretically, contract testing a message queue is like contract testing an HTTP request/response pair where the request is implicit (you could argue the "request" is the subscription to the queue).

When testing/verifying an HTTP Pact contract, Pact provides both the transport (mock HTTP client/server), and the content (content shape and constraints).

At the moment, when doing the same test with a Message Pact, Pact only provides the content / constraints. There's no mock consumer/provider - the data transport is not tested by the Pact framework. This means that a message pact test has slightly less coverage than the corresponding HTTP pact would - it's not testing that your queue library is set up and invoked correctly (unless you do that testing yourself).

The Pact Spec V4 Plugin proposal exists to make it easier to address this gap in the future, so that a message pact test will be able to more easily cover the queue libraries too. But, it's not something that is available to use today.

it requires starting an instance of the server itself which introduces a lot of complexity.

This feels like it might be a software design issue that a bit of refactoring would be able to solve. You should be able to run message pact consumer tests without starting the whole server. This will be specific to your usecase and design, but join us in #general on https://slack.pact.io/ and we can probably help you.

It is important to keep in mind that Contract Testing =|= Functional Testing. So we're not going to retest with different messages because that would be functional testing.

Yes, this is a good observation. In general, you want to test that your consumer can understand every type of message that the provider can send, and in the case of message queues, this is usually only one type (although it is still sometimes a few).

It's a little off the topic of your question, but there's a small caveat here in that although a Pact test is not a functional test, it is ok if it has some functional coverage. All testing is risk reduction - and the closer you can get to testing the actual code you will be running, the better the risk is reduced. For this reason, I usually put any mocks as deep in the service as is practical. Of course, I would cover the behaviour of the service with its own unit tests, but I think it's good if the pact test (which doesn't cover the behaviour directly) happens to still exercise some of the behaviour in the course of contract verification. Happy to elaborate on that if you need.

The template expression ${{}} is evaluated at compile-time(before the jobs run), which means it cannot access to the variables that are dynamically set at the runtime(after the jobs start). So you cannot use template expression ${{}} in above scenario. See below description from here.

Within a template expression, you have access to the parameters context that contains the values of parameters passed in. Additionally, you have access to the variables context that contains all the variables specified in the YAML file plus many of the predefined variables (noted on each variable in that topic). Importantly, it doesn't have runtime variables such as those stored on the pipeline or given when you start a run. Template expansion happens very early in the run, so those variables aren't available

You can use conditions as a workaround. You need to add multiple tasks to be executed on the conditions. See below example:

Here is a working example for what you're looking for in the question.

It's possible to build apps that use old expo sdks, but I'm not sure if play store will accept those old versions, there was a lot of changes around privacy policy and terms of service plus at certain point google started to require 64 bit binaries(I'm not sure if sdk 32 already had those changes). If that's the case your only option is to upgrade to supported SDK.

If you want to build that app, you can do that with turtle-cli https://www.npmjs.com/package/turtle-cli. This tools executes locally the same code that runs on expo servers, but it's not fully integrated with expo infrastructure, so you will need to provide keystore and all the passwords manually in the cli and either your expo credentials(if you use expo publish) or url to the js bundle (if you self-host). You will need to use old enough version of turtle-cli that still have that sdk, you can consult CHANGELOG here https://github.com/expo/turtle/blob/master/CHANGELOG.md to check that.

Your WM_SIZE handler is missing a break statement:

The headlines are all in that list, issue is the indent of your print, it should be outside the loop and print the list only ones.

You can take advantage of callFake that will be called everytime the function is called.

It seems that testRetest() in psych isn't well-suited for looking at single items; it's geared towards multiple items which form a scale (if you look at the documentation, the return values - apart from r12 - don't work for a single item).

If you're looking for a simple test-retest reliability, how about just using: