ginkgo | Python service microframework | Microservice library

I do not know the Ginkgo PACS, but quite likely your retrieval fails because your request is malformed.

See PS3.4, C.4.2.1.4.1 Request Identifier Structure

Your request must include the attribute Query Retrieve Level (0008,0052) which I assume will be "STUDY" in your case since the Accession Number is a study-level attribute.

Furthermore it must contain

"Unique Key Attributes, which may include Patient ID (0010,0020), Study Instance UIDs (0020,000D), Series Instance UIDs (0020,000E), and the SOP Instance UIDs (0008,0018)"

That is, you have to specify the scope of your retrieve request by providing unique identifiers for the patient/study/series/image(s) you want to move - and nothing else!

So Accession Number may be used to query (C-FIND) for the corresponding Study Instance UID that you need for the C-MOVE. But it is not allowed in the C-MOVE-Request.

Caution: Whether or not you must include or omit the Patient-ID (0010,0020) in your C-MOVE request depends on the information model that you have negotiated during association establishment and that you select by choosing the presentation context for your message. You must include it in Patient Root, you must not include it in Study Root.

Some module in the transitive dependencies of github.com/onsi/ginkgo/ginkgo added a requirement on some version of gopkg.in/fsnotify.v1, which resolves to the repository hosted at github.com/fsnotify/fsnotify.

However, the go.mod file in that repository declares its canonical import path to be github.com/fsnotify/fsnotify, not gopkg.in/fsnotify.v1.

If you are using Go 1.14, the rest of the error message (which seems to be truncated) should tell you exactly which dependency is using the non-canonical path. The long-term fix is to move that dependency over to the canonical path and upgrade your other dependencies such that gopkg.in/fsnotify.v1 is no longer required.

Do you plan to run tests in parallel? If so, then results will be unpredictable. In that case it's recommended to have a separate instance of external resources for each process.

I would recommend to look at how controller tests are implemented in controller-runtime. I believe, they create new Control Plane with envtest each time BeforeSuit function is called. And as ginkgo docs states:

when running in parallel, each parallel process will run BeforeSuite and AfterSuite functions

After @Volker's comment on my Q I knew I had to take the challenge and went straight for the source code of Go's testing package. While @marco.m's suggestion is helpful in many cases, it cannot handle my admittedly slightly bizare usecase. testing's mechanics relevant to my original question are as follows, heavily simplified:

• cover.go: implements coverReport() which writes a coverage data file (in ASCII text format); if the file already exists (stale version from a previous run), then it will be truncated first. Please note that coverReport() has the annoying habit of printing some “statistics” information to os.Stdout.
• testing.go:
  • gets the CLI arguments -test.coverprofile= and -test.outputdir= from os.Args (via the flags package). If also implements toOutputDir(path) which places cover profile files inside -test.outputdir if specified.
  • But when does coverReport() get called? Simply spoken, at the end of testing.M.Run().

Now with this knowledge under the belt, a crazy solutions starts to emerge, kind of "Go-ing Bad" ;)

• Wrap testing.M in a special re-execution enabled version reexec.testing.M: it detects whether it is running with coverage enabled:
  • if it is the "parent" process P, then it runs the tests as normal, and then it collects coverage profile data files from re-executed child processes C and merges them into P's coverage profile data file.
  • while in P and when just about to re-execute a new child C, a new dedicated coverage profile data filename is allocated for the child C. C then gets the filename via its "personal" -test.coverprofile= CLI arg.
  • when in C, we run the desired action function. Next, we need to run an empty test set in order to trigger writing the coverage profile data for C. For this, the re-execution function in P adds a test.run= with a very special "Bielefeld test pattern" that will most likely result in an empty result. Remember, P will -- after it has run all its tests -- pick up the individual C coverage profile data files and merge them into P's.
• when coverage profiling isn't enabled, then no special actions need to be taken.

The downside of this solution is that it depends on some un-guaranteed behavior of Go's testing with respect to how and when it writes code coverage reports. But since a Linux-kernel namespace discovery package already pushes Go probably even harder than Docker's libnetwork, that's just a quantum further over the edge.

To a test developer, the whole enchilada is hidden inside an "enhanced" rxtst.M wrapper.

If I understood your question correctly, you want to wait for the server to start before running tests.

Instead of manually sleeping, you should use wait-for-it.sh (or an alternative). See the relevant Docker docs for more information.

For example:

Actually you don't need JavaScript to achieve that. You can do it in pure CSS. But to answer your question first, the problem is that you attach the click event the label and the function is called only when input is clicked. So if "email", "phone" or other labels are clicked the function is not called and therefore the elements are not hidden.

Here is an example of how to do it using only CSS:

Ginkgo handles its configuration in the github.com/onsi/ginkgo/config package, where the runtime configuration is available for modifications.

Making Ginkgo far more patient can be achieved with:

config.DefaultReporterConfig.SlowSpecThreshold = time.Hour.Seconds()

You need to move your source code into $GOPATH or use go modules.

I think you are using Skip method incorrectly. It should be use inside spec like below, not inside BeforeSuite. When used inside spec it does show up as "skipped" in the summary.