We Keep Coding

Use Robot Framework logging file at the end of test case execution

I am a new Robot Framework user and have a question regarding the log file that it makes at the end of executing testcases. I would like to use the html file it creates and upload it automatically to the correct ticket. I already have python code that works to upload the file and it can be used as a keyword, but I am not sure how I can call upon that keyword as a test teardown step as at that point the logging probably is not created yet..
Is this correct and if so: is there another way to automatically call a python function to upload the html file after executing a testcase?

Yes, you can use things as below:
Test Teardown Run keyword if test Passed/Failed Name_of_kw
Add this to your settings section of .robot file.
Now, define the kw: (Import Process Library first in your robot file)
Name_of_kw
Start Process <tab> python <tab> path_to_file.py<tab> alias=prog
Wait for Process prog #wait until it gets completed
Get Process Result prog stdout=yes #to make sure you have uploaded it
================
more details at -https://robotframework.org/robotframework/latest/libraries/Process.html#library-documentation-top

I've been facing the same problem and I've got an alternative solution for getting log files (log.html, report.html, output.xml) in same execution and upload them to a FTP Server.
I created a python script in Robot Framework's root project folder:
import subprocess
import os.path
import time
arguments = sys.argv
subprocess.run(arguments)
logs = ['log.html', 'report.html', 'output.xml']
while not os.path.exists(logs[0] and logs[1] and logs[2]):
time.sleep(1)
do_something()
Instead of running:
robot .\tests\...\suite
Run:
python script.py robot .\tests\...\suite
In that way, you will be able to work with output files when tests or suites are finished.
If you run robot's command with -d flag to save results on a different folder, consider using automatic variable from Robot Framework called ${OUTPUT DIR} to get full source path and save it to txt file on root folder. That's because you'll be able to read it and find the logs in your script.py.

How do I write to the console from a pytest plugin during the collection phase?

I'm writing a pytest plugin that needs to warn the user about anomalies encountered during the collection phase, but I don't find any way to consistently send output to the console from inside my pytest_generate_tests function.
Output from print and from the logging module only appears in the console when adding the -s option. All logging-related documentation I found refers to logging inside tests, not from within a plugin.

In the end I used the pytest-warning infrastructure by using the undocumented _warn() method of the pytest config object passed to or anyway accessible from various hooks. For example:
def pytest_generate_tests(metafunc):
[...]
if warning_condition:
metafunc.config._warn("Warning condition encountered.")
[...]
This way you get additional pytest-warnings in the one-line summary if any was reported and you can see the warnings details by adding the '-r w' option to the pytest command line.

Action hooks in python: no output

I've been working on an Openshift app where the action hooks are written in Python.
The action hooks run, and work, but I can not get any output to display when I create the app. So when I run rhc app create ... the app is successfully created, but none of the status or debug messages I try to output ever display.
The code gets called like this:
b = library.Object()
b.build()
I have tried:
Adding a logging function to the object and adding b.showlog() to the code above.
print "Message with value: {0}".format(variable) from inside the build hook script
print >>sys.stderr, "Something bad happened: '{0}'...".format(return_code) from inside the build hook script
When I've written action hooks in bash, echo ... works fine.
This exact question doesn't seem to have been answered before, though there are questions that are superficially similar.

You don't get any action hook output during an app create. You will only see it during a "git push" when you update code. I would suggest having the output write to a log file in your ~/app-root/data directory instead so that you can view it later. Also, if you catch it at the right time, you can ssh into your application while it is being created the first time.

Robot framework - Post run hook to send message

I run multiple test suites in a single pybot command like this,
pybot suite1.robot suite2.robot suite3.robot
Now, each one of these robot suites add one key,value into a global dictionary (this test variable contains some metrics that needs to be returned to the test-invoker) as,
{ "suite1-res" : xxxx,
"suite2-res" : yyyy,
"suite3-res" : zzzz }
Now, this dictionary needs to be posted to a kafka/any messaging broker. I like this functionality to be written in a post-run hook function/robot case that will be ran only once at the end of all robot cases.
Can this post-run hook functionality be added as a runtime parameter (like suite teardown) instead of passing it as an extra robot test case argument.

Use a suite file
If you put all of those suites in a folder, you can attach a suite teardown in the folder which will run after all of the child suites finish.
$ mkdir all_tests
$ mv suite*.robot all_tests
$ # edit all_tests/__init__.robot to have a suite teardown
$ pybot all_tests
Use a listener
You can use a listener, which can collect the data and run a post processing step. For example, your tests could attach the metrics as suite metadata which the listener will get when end_suite is called for each suite. The listener can store all of this metadata, then process it when close gets called. For more information see Using the listener interface in the robot framework users guide, and the documentation for Set Suite Metadata keyword in the builtin library.
Write a custom script
For more information, see the section titled Test Suite Directories in the robot framework users guide. For this to work your tests would have to write the dictionary to a file.
Your other choice is to write a simple bash or batch script that runs the pybot command, and then does whatever post processing you want. Your tests will need to somehow make the dictionary data available. For example, you could store the data as suite metadata, and then have the post-processing step pull that data out of the output.xml. Or, your suites could write the data to a file.

Quality Center Modify Status of Automatic Runner via OTA

A simple need in Quality Center.
Background:
In HP Quality Center -> Test Lab, you can create a testset having many testcases. You can run the testset or individual testcase by clicking on the Run (which starts Test Run Scheduler). Considering that a test script (considering Python) exists for the testcase, when Run is clicked a Automatic Runner popup is seen where you have three columns:
TestName, Run on Host, Status
I am aware of the OTA API which can be really useful to write a testscript.
My question is how can I modify the Final Status seen on the Automatic Runner via the testscript (and OTA API).
I have this requirement because when my following testscript is called, I wish to display a message - 'Testcase Finished' instead of 'Error: Failed to Post Run'. The 2nd message is displayed because my testscript purposely cancels the Run. Here is the script:
def Test_Main(Debug, CurrentTestSet, CurrentTSTest, CurrentRun):
TDOutput.Print('Do something before cancel')
CurrentRun.CancelRun()
TDOutput.Print('Do something after cancel')

The answer to this question is that.... it cannot be done!! The reason being, QC has its own way of knowing if the testscript passed successfully, it will make the status Passed. Like in the case of...
def Test_Main(Debug, CurrentTestSet, CurrentTSTest, CurrentRun):
"""
"""
TDOutput.Print("Bye")
The status is Passed.
If any Traceback was caught in the script, it will show the error message and change the status to Failed or Not Complete. I guess QC did not make this tweak-able.
Only thing what we can do is store the output shown on the prompt and attach it to the Run.