Is there any function similar to click_link_within in jbehave?
I want an easy way to click a link which is selected by it's text within a certain area on the page.
JBehave is a framework to drive tests based on BDD syntax which promotes communcation with stakeholders. It can be translated to any form of action to any type of application but this has to be done by integrating JBehave with the underlying technical framework.
So the answer is no, not automatically. And yes, you are totally free to integrate with any technical framework you choose.
Study the examples by cloning the git repo or read more of the documentation on jbehave.org.
Related
PROBLEM: There are two Jira projects: A & B. When project A transitions, project B should as well. Issues from projects A & B are linked.
RESEARCH: There is an ILA plugin for Jira and in its Update Status Transition you can select issues with JQL and set their statuses.
I've conducted a JQL, but it is related to current issue, and I need it is a variable which is unavailable (find issues of project A, linked to issue B-3 from project B):
project = "A" AND issue IN LinkedIssuesByJQL("issue = B-3")
QUESTION: How to refer to a variable like $currentIssue? Any other free plugins? Maybe using Jira API?
I don't know the ILA plugin for Jira but it seems that it does not provide the functionality you require. You might want to reach out to them and ask if they can implement this feature for you. But based on their documentation, it's a rather simple plugin for smaller use cases.
However, your use case also sounds you might want to use some more automation than this. Here are three alternatives you might want to consider for your problem:
Jira Service Desk Automation
In case one of your projects is a Jira Service Desk project on Jira Cloud, then you could use Jira Service Desk Automations which is a free feature. It allows to define rules and actions to be performed. You can find more information here.
Automation Plugins
There are a few other plugins (or 'apps') available on the Atlassian marketplace to automate certain tasks in your projects. They work similar to the Jira Service Desk Automation but are much more powerful and can be used in more than only Jira Service Desk (of course they support regular Jira projects). Your use case should be possible with them as well. Popular apps are Automation for Jira (there is a lite/free version available) or ScriptRunner (here you have to write your own scripts).
Issue Synchronization Plugins
There are also specialized plugins in case you want to continuously make sure that the issues in your two projects have the same data and the issue updates are synchronized to the other side as soon someone updates an issue. They not only provide you with settings for workflow updates but also regular issue field updates. Popular ones are Exalate Jira Issue Sync or Backbone Issue Sync, but none of them is free to use. (Note: I'm currently working for the team behind Backbone Issue Sync).
Although neither of the unswers suggest free plugins as requested, I also had some helpful comments in Atlassian Community:
Sync fields is a plugin which is used to change and replicate all the data that is in a issue to another issue in other project ,may be this is similar plugin.
There are many options out there to do linked transitions:
Jira Misc Workflow Extensions has a transition linked issues post function
JSU Automation Suite for Jira Workflows also has one
You can also (partial list)
Automation for Jira, (this one was recently purchased by Atlassian)
one of the scripting addons (scriptrunner, power scripts)
Jira Workflow Toolbox
So there are many options. Take a look at each of the addons and see which one has the most features that you would use in addition to linked transitions. They are all good choices, and all have their pros and cons.
I've a very basic question about the practical operation of software plugin systems. I understand how a simple plugin design works, ie one where a plugin adds to a hosting application. Eg a plugin adds a new filter to a paint program. The host knows it has to call a method called filter which the plugin provides. In this case all plugins are independent.
My question relates to the case when one plugin can use the facilities in another plugin. For example there may be a plugin that provides the ability to plot data while another plugin generates data. If the data generator plugin has never seen the graphing plugin before I assume there is no way for it to know what methods to call in the graphing plugin. I presume that in these cases, the developer of the data generator plugin must have access to a description of the graphing plugin API either in the form of an abstract class or an interface. Is this how plugin dependency operates, ie plugins know explicitly about the Apis that other plugins might have?
I've just built such a plugin system and for plugins to be able to use other plugins I am including in the source code copies of the plugin interfaces each plugin needs to know about. The problem with this approach is that if a new plotting plugin comes along but with a different API, there is no way for the data generator plugin to use it without first being recompiled so that it is aware of the new API. This doesn't seem right to me.
I know this may seem to be a very simple question and have an obvious answer but I've spend hours searching the internet and I've not come across an explicit statement concerning this question.
If your "new plotting plugin" has a different API from the one your code knows about, there is no alternative but to make your code aware of this API.
If you are in control of all this, including the various plotting plugins, then you c/should specify a standard Plotting API that all plotting plugins need to implement/support. That is about the only way that you can have different providers (plugins) for some task.
A standard "language" is the way to ensure that you can use multiple implementors of an interface (providers of a service). It is also the way that you can have multiple users of the same interface (consumers of a service).
The need/wish for multiple providers of a task and for multiple consumers of a provider is probably what led to the creation of standards such as OAuth, and of protocols such as HTTP, SMTP and the like.
I am writing features with the same verbiage for some scenarios.
Feature: User Management
Scenario: Edit an existing user's details
Given a user exists
and
Feature: Group Management
Scenario: Add a user to a group's membership
Given a user exists
And a group exists
In SpecFlow is there a good way to define what step each feature calls? Am I going about this the wrong way with my scenario writing? Should I just bite the bullet and change my given statements to denote what feature they apply to? I'm new to BDD and SpecFlow so any help is appreciated.
The Gherkin format (that the tools in the Cucumber-family, like SpecFlow uses) does not have any structure for sharing steps between features (inside a feature, you can use backgrounds).
The meaning behind this is that the features should be self-describing and complete in their own. With using the Background section, you can avoid having too long scenarios, but still having all information together in the file. You have to repeat the shared steps for each feature, though.
As an alternative, you can also create event bindings (that is like "hooks" in cucumber), where you can implement some shard logic. But this shared logic has to be implemented in .NET then.
Introduction:
Now I know this question could be very broad and it would be too hard to answer without me asking something specific. So All I ask is just some direction, or a brief high level explanation of a design, or maybe there is already some framework out there that could help me get started...I'm not sure.. I have never designed a plugin architecture before, so maybe there is some resource/example you could point me to on the web that would help me learn so that I may come up with my own solution.
Details of my question:
My intention is I would like to create a plug-in architecture for a new pet-project that I am building in ASP.NET MVC.
I would like to design it so that it has some sort of plug-in ability for all, or at least most, of the application's components.
The reason I would like to do this, is so that I may be able to do deployments with nearly zero down time. The idea is that when I want to deploy the latest version I would drop in the new DLLs into a specific folder, and the application would load up the new plug ins and that is it.
For exapmle, lets say I add a new "contacts" feature to my web application where users can search, add and delete contacts. I would like to be able to deploy that by way of plugins.
Is something like this even possible for Web Applications? Or am I just dreaming?
It's definitely possible.
You will need to define a pretty comprehensive interface that represents everything your plugins will have to do. You should approach it by differentiating what is "core" to your application, and where the extensibility points are. For example, where will the plugins be accessed? Will they be tabs on a page, or links in a sidebar? What properties does each plugin need to have in order to fit into the plugin container?
Generally, plugins are enumerated via reflection by looking for assemblies that implement the plugin interface.
Just for encouragement, we've done this with an enterprise product that provides a generic framework for "management" interfaces for web sites. Developers just need to drop in a plugin dll that builds specific property pages, and they show up in the management interface menu, all the navigation is taken care of, and their dll's just have to worry about their own domain logic.
There is always the dll-way where you define some interfaces that plugins follow.
But for web application, especially ASP.NET MVC, you need a controller, views and so. Probably these can be included in a dll file using prepared controller factory to handle that, but it would be hard to develop these plugins.
Some inspiration for code (or db) embedded content: Haacked about that
ASP.NET MVC version 2 will support areas, where you can put some parts of the application into different folders within the app. This way you can just upload some files and the app will recognize these new files. Read more there Haacked blog
PS: I found another person here on S.O. asking the same question as me:
Plug-in architecture for ASP.NET MVC It might be useful for someone researching the same topic.
I'm curious to know if any basic CMS code has been written for ASP.NET MVC.
The reason I ask is, I'm making a data-driven website for a client, and I've already spent a significant amount of time building it from the ground-up in MVC, but now the client wants content management facilities.
Basically they want to be able to add/edit/remove articles and have revision control.
It would be great if I could somehow 'bolt on' the content management without having to start again from scratch, developing it under an existing CMS.
Should I build the article management and revision control myself, or should I re-use some existing package?
N2 does what you describe - "bolts on" to existing ASP.NET solutions (including MVC).
Also, kooboo is interesting http://www.kooboo.com
(I know this question is old, but it still comes high up for the relevant search terms.)
Today I discovered Meek, http://www.adventuretechgroup.com/labs-meek/, and it was very simple and unobtrusive to add to my MVC project, which I believe is what the original poster would have wanted - bolting on CMS as a feature rather than having it take over your entire site.
Piranha CMS is well suited to bolting on to an existing application. The author of it describes why and how here. To quote straight from that source:
"Our focus is content management and to have a transparent and lightweight API for developers. Piranha CMS has almost no components or helpers that render any HTML at all, it simply provides a database, a manager interface and a routing mechanism for retrieving the correct data for the current request.
In the case of you having an existing website you could actually bypass the routing completely, add one page at a time in the manager interface and then manually load the Page model in you existing page. This would allow you to keep your original application exactly the same but manage the content form the manager interface."
If you are still looking, I've published my new open source CMS here:
MVCwCMS
I'm actively working on it so I will push more updates soon.
Here is also a quick summary as to how Telerik Sitefinity does it:
http://www.sitefinity.com/mvc-cms
in brief - allows you to plug in standard system.web.mvc.controller classes as widgets, lets you use the API for anything including model binding, standard Razor for a view engine etc.
There is also Oxite which I believe is more of a blog engine.
Heve a look at AtomicCms it's a free open source content management system based on ASP.NET MVC 1.0
http://atomiccms.codeplex.com
Check for Orchard ;-)
It is based on asp.net mvc.