how can I learn this before connecting anything.
example
does_signal_exist(widget, signal):
pass
button = Gtk.Button()
does_signal_exist(button, "clicked") # returns True
does_signal_exist(button, "hello") # returns False
does_signal_exist(button, "unboxed") # returns False
does_signal_exist(button, "button-press-event") # returns True
There's a wondrous tool called 'manual' or 'reference'. Look for the Gtk-3.0 manual, and click on Classes, and look for Gtk.Button. Look for Signals. If not there you can do the same for the signals inherited from previous Objects.
Using help(button or even help(Gtk.Button) (inside Python3, either in interactive or in a program), you have access to all methods, and lots of other information about the class and the instance.
Using the manual mentioned above, check out the GiRepository module - these are functions which you can use to look inside Gtk, its classes and properties.
And you can just check if it works: Use try:/except: to check if you can actually connect to the signal/event you are interested in.
def does_signal_exist(gtkWidgetObj, sigTag):
try:
gtkWidgetObj.emit(sigTag)
return True
except:
return "unknown signal name" not in format_exc():
Related
I am trying to use a different warden strategy to authenticate my action cable end points.
But the strategy is not getting called. I tried to place warden.authenticate!(:action_cable_auth) in a controller to test but none of the debug statements are getting printed on console.
Below are the relevant part of the code.
config/initializers/warden.rb
Warden::Strategies.add(:action_cable_auth) do
def valid?
#check if its a websocket request & for action cable?
#Rails.logger.error request.inspect
p 'checking if strategy is valid?'
true
end
def authenticate!
p 'unauthenticate the user'
fail!('user not active')
end
end
in my controller
warden.authenticate!(:action_cable_auth)
Assuming that you are setting your initializer in the proper place, please recall that if your session is already instantiated somewhere else (for example if you authenticate the user at the point your action is being called, then your strategy will never be called.
This is basically how warden works: if some valid? strategy returns a success! then no other will be called as soon as any authenticate! method in the list of strategies is successful.
Please also be sure that if you want your strategy up the list of strategies to check you may need to also shift it up on the list, such as:
manager.default_strategies(scope: :user).unshift(:action_cable_auth)
Where the manager is your Warden::Manager instance. The scope may also be optional (this is an example where the user scope is used alongside Devise), but you may check your instance .default_strategies to figure out where it is and where you want it.
I'm making a library with a module that when use'd injects some functions dependant on the contents of a directory, and I want to test the behaviour with different directories. Currently I get the path to the directory through application config with Application.get_env/3.
If I'm changing the directory Application.put_env/4 it means my tests have to run sequentially as this is effective a global value, correct?
Can I stub out the call to Application.get_env/3? Or should I be passing in the value in another way? (such as via the use macro)
The simplest way is to pass in the value as an argument. Your module could depend on Application.get_env only absent a passed in value. Something like:
Application.put_env(MyApplication, :some_key, "hello")
defmodule Test do
def test(string \\ Application.get_env(MyApplication, :some_key)) do
IO.inspect(string)
end
end
# Default behaviour
Test.test # => "hello"
# In your tests
Test.test("world") # => "world"
I want to ensure that my EventNotifier object catches and logs an exception to the Rails logger, so I writed the following rspec test using rspec-mocks:
describe EventNotifier do
before(:all) do
RSpec::Mocks::setup(self)
end
it 'logs exception on error' do
error = RuntimeError.new('simulated for tests')
EventDispatcher.should_receive(:dispatch).with('a message').and_raise(error)
Rails.logger.should_receive(:warning).with(error)
subject.notify('a message')
end
end
class EventDispatcher
def dispatch(message)
# stuff
end
end
class EventNotifier
def notify(message)
EventDispatcher.dispatch(message)
rescue RuntimeError => e
Rails.logger.warning(e)
end
end
The test passes with bells and whistles, but I did a big mistake. Can you spot it? Indeed, the Rails method to log a warning is warn, not warning. So this code will fail when used for real.
Is there a way to make rspec-mock forbid mocking methods that do not exist on the original object?
Another example where it can be useful: if I decide to rename EventDispatcher#dispatch as EventDispatcher#route, then the test still passes. If it was java, it would have failed at compilation because the interface has changed. With rspec-mock, I do not know how to make it fail automatically.
It will be possible with rspec-mocks 3.0 which introduces verifying doubles:
Verifying doubles are a stricter alternative to normal doubles that provide
guarantees about what is being verified. When using verifying doubles, RSpec
will check that the methods being stubbed are actually present on the
underlying object if it is available. Prefer using verifying doubles over
normal doubles.
So given these classes (examples taken from the spec):
class ConsoleNotifier
def notify(msg)
puts message
end
end
class User < Struct.new(:notifier)
def suspend!
notifier.notify("suspended as")
end
end
This example would pass because the method notify exists for a real ConsoleNotifier instance:
describe User, '#suspend!' do
it 'notifies the console' do
notifier = instance_double("ConsoleNotifier")
expect(notifier).to receive(:notify).with("suspended as")
user = User.new(notifier)
user.suspend!
end
end
If the notify method is renamed as publish, the example would fail because expectations are on the method notify and that method does not exist on target object.
# would make example fail
class ConsoleNotifier
def publish(msg)
puts message
end
end
If we add a color argument to the notify method, it will fail too because the method arity is incorrect in the expectation (wrong number of arguments).
class ConsoleNotifier
def notify(msg, color)
puts color + message
end
end
When putting expectations on class, like EventDispatcher.should_receive(:dispatch) or expect(EventDispatcher).to receive(:dispatch), the created double is named a partial double in rspec-mocks vocabulary.
To make partial doubles act like verifying doubles, the verify_partial_doubles configuration option must be set:
RSpec.configure do |config|
config.mock_with :rspec do |mocks|
mocks.verify_partial_doubles = true
end
end
And it will automagically ensure that the EventDispatcher class has a dispatch method. So if this method is renamed, the test will fail, as expected!
I've got the following model
class User < ActiveRecord::Base
before_create :set_some_values
private
def set_some_values
#do something
end
end
In specs I'm using Fabrication gem to create objects but I can't find a way to stub the set_some_values method. I tried
User.any_instance.stub!(:set_some_values).and_return(nil)
but Fabrication seems to ignore this. Is it possible to do?
This is why I don't like ActiveRecord callbacks -- because if you want to have nothing to do with a callback (because, say, you're making a call to an external service inside the callback) you still have to be concerned about stubbing it out. Yes you could stub out methods inside the callback, but it's the same problem, and actually it's a bit worse because now you are concerned about something inside a method you want nothing to do with.
As usual there are multiple options here.
One option which I've used a lot in the past is, add a condition to your callback that turns it off by default. So your Post class could look like:
class Post
before_save :sync_with_store, :if => :syncing_with_store?
def syncing_with_store?; #syncing_with_store; end
attr_writer :syncing_with_store
def sync_with_store
# make an HTTP request or something
end
end
Now wherever you really want to call the callback (perhaps in your controller or wherever), you can set post.syncing_with_store = true before you call post.save.
The downside to this approach is, it's something that you (and other devs working with you) have to keep in mind, and it's not really obvious that you have to do this. On the other hand, if you forget to do this, nothing bad happens.
Another option is to use a fake class. Say you have a Post that pushes its data to an external data store on save. You could extract the code that does the pushing to a separate class (e.g. Pusher) which would be accessible at Post.pusher_service. By default, though, this would be set to a fake Pusher class that responds to the same interface but does nothing. So like:
class Post
class << self
attr_accessor :pusher_service
end
self.pusher_service = FakePostPusher
before_save :sync_with_store
def sync_with_store
self.class.pusher_service.run(self)
end
end
class FakePostPusher
def self.run(post)
new(post).run
end
def initialize(post)
#post = post
end
def run
# do nothing
end
end
class PostPusher < FakePostPusher
def run
# actually make the HTTP request or whatever
end
end
In your production environment file, you'd set Post.pusher_service = Pusher. In individual tests or test cases, you'd make a subclass of Post -- let(:klass) { Class.new(Post) } -- and set klass.pusher_service = Pusher (that way you don't permanently set it and affect future tests).
The third approach, which I have been experimenting with, is this: simply don't use ActiveRecord callbacks. This is something I picked up from Gary Bernhardt's screencasts (which, by the way, are pretty amazing). Instead, define a service class that wraps the act of creating a post. Something like:
class PostCreator
def self.run(attrs={})
new(attrs).run
end
def initialize(attrs={})
#post = Post.new(attrs)
end
def run
if #post.save
make_http_request
return true
else
return false
end
end
def make_http_request
# ...
end
end
This way PostCreator.run(attrs) is the de facto way of creating a post instead of going through Post. Now to test saves within Post, there's no need to stub out callbacks. If you want to test the PostCreator process, there's no magic going on, you can easily stub out whichever methods you want or test them independently. (You could argue that stubbing out methods here is the same as stubbing out AR callbacks, but I think it's more explicit what's going on.) Obviously this only handles post creation, but you could do the same for post updating too.
Anyway, different ideas, pick your poison.
The #set_some_values method here is called when you call #save on the record. So it has nothing to do with the constructor and therefore you don't need to stub User.any_instance -- just make your record and then do a partial stub, as in:
record.stub(:set_some_values)
record.save
I have recently started working on twisted not much familiar with its functions.I have a problem related to "deferToThread" method...my code is here to use this method
from twisted.internet.threads import deferToThread
from twisted.internet import reactor
results=[]
class Tool(object):
def exectool(self,tool):
# print "Test Class Exec tool running..........."
exec tool
return
def getResult(self,tool):
return results.append(deferToThread(self.exectool, tool))
to=Tool()
to.getResult(tools)
f=open(temp).read()
obj_tool=compile(f, 'a_filename', 'exec')
[ at 0x8ce7020, file "a_filename", line 1>, at 0x8cd4e30, file "a_filename", line 2>]
I am passing tools one by one in getResults() method it executs successfully & prints the results what script written in the file objects.
I have to store the result of tools executing in some variable so that I can save it in database.How to achieve this cause when i call re=to.getResult(tools) and print "re" it prints none.
I HAVE TO STORE ITS RESULTS IN DATABASE? IS THERE SOMETHING I CAN DO?
thanx in advance
There are two problems here.
First, deferToThread will not work if you never start the reactor. Hopefully this code snippet was actually extracted from a larger Twisted-using application where the reactor is running, so that won't be an actual problem for you. But you shouldn't expect this snippet to work unless you add a reactor.run() call to it.
Second, deferToThread returns a Deferred. The Deferred fires with the result of the callable you passed in. This is covered in the API documentation. Many APIs in Twisted return a Deferred, so you might want to read the documentation covering them. Once you understand how they work and how to use them, lots of things should be quite a bit easier.